screenci 0.0.21 → 0.0.23

package/dist/src/instrument.js

@@ -1,76 +1,14 @@
-import { logger } from './logger.js';
-import { isInsideAutoZoom, getZoomDuration, getZoomEasing, getPostZoomInOutDelay, getLastZoomLocation, setLastZoomLocation, } from './autoZoom.js';
 import { isInsideHide } from './hide.js';
-import { ZoomScrollHandler } from './scroll.js';
+import { changeFocus } from './changeFocus.js';
+import { CLICK_DURATION_MS, assertDurationOrSpeed, buildMouseDownEvent, buildMouseUpEvent, getOriginalLocatorCheck, getOriginalLocatorClick, getOriginalLocatorSelect, getOriginalLocatorTap, getOriginalLocatorUncheck, getOriginalMouseDown, getOriginalMouseHide, getMousePosition, getOriginalMouseShow, getOriginalMouseUp, isMouseVisible, performMouseClickAction, performMouseDown, performMouseHide, performMouseMove, performMouseShow, performMouseUp, resolveMouseMoveDuration, setOriginalLocatorCheck, setOriginalLocatorClick, setOriginalLocatorSelect, setOriginalLocatorTap, setOriginalLocatorUncheck, setMouseVisible, setOriginalMouseClick, setOriginalMouseDown, setOriginalMouseHide, setOriginalMouseMove, setOriginalMouseShow, setOriginalMouseUp, } from './mouse.js';
 let activeClickRecorder = null;
 export function setActiveClickRecorder(recorder) {
     activeClickRecorder = recorder;
 }
-/**
- * Evaluate a polynomial easing function at normalized time t ∈ [0, 1].
- * Returns the eased progress value (0–1).
- */
-function evaluateEasingAtT(t, easing) {
-    if (t <= 0)
-        return 0;
-    if (t >= 1)
-        return 1;
-    switch (easing) {
-        case 'linear':
-            return t;
-        case 'ease-in':
-            return t * t * t;
-        case 'ease-out':
-            return 1 - (1 - t) * (1 - t) * (1 - t);
-        case 'ease-in-out':
-            return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
-        case 'ease-in-strong':
-            return t * t * t * t;
-        case 'ease-out-strong':
-            return 1 - (1 - t) * (1 - t) * (1 - t) * (1 - t);
-        case 'ease-in-out-strong':
-            return t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
-        default: {
-            const _ = easing;
-            throw new Error(`Unknown easing: ${_}`);
-        }
-    }
-}
-/** Tracked cursor position per page, updated after each animated move. */
-const mousePositions = new WeakMap();
-/** Tracks cursor visibility per page (true = visible). Defaults to true. */
-const mouseVisibilities = new WeakMap();
-/** Stores the original (un-instrumented) mouse.move per page so internal
- *  cursor animations don't emit addInput recorder events. */
-const originalMouseMoves = new WeakMap();
 const instrumented = new WeakSet();
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-const CLICK_DURATION_MS = 200;
-const PRE_ACTION_SLEEP = 50;
-const POST_ACTION_SLEEP = 250;
-function assertDurationOrSpeed(duration, speed, context) {
-    if (duration !== undefined && speed !== undefined) {
-        throw new Error(`[screenci] ${context} accepts either duration or speed, not both.`);
-    }
-    if (duration !== undefined && (!Number.isFinite(duration) || duration < 0)) {
-        throw new Error(`[screenci] ${context} duration must be a finite number >= 0.`);
-    }
-    if (speed !== undefined && (!Number.isFinite(speed) || speed <= 0)) {
-        throw new Error(`[screenci] ${context} speed must be a finite number > 0.`);
-    }
-}
-function resolveMouseMoveDuration(page, targetX, targetY, options) {
-    const { duration, speed, defaultDuration, context } = options;
-    assertDurationOrSpeed(duration, speed, context);
-    if (speed !== undefined) {
-        const startPos = mousePositions.get(page) ?? { x: 0, y: 0 };
-        const distancePx = Math.hypot(targetX - startPos.x, targetY - startPos.y);
-        return (distancePx / speed) * 1000;
-    }
-    return duration ?? defaultDuration ?? 0;
-}
 const LOCATOR_RETURN_METHODS = [
     'locator',
     'getByAltText',
@@ -107,294 +45,129 @@ const FRAME_LOCATOR_SELF_RETURN_METHODS = [
     'last',
     'nth',
 ];
-function canUseDirectMouseClickAfterScroll(options) {
-    if (!options)
-        return true;
-    const unsupported = [
-        'force',
-        'modifiers',
-        'noWaitAfter',
-        'timeout',
-        'trial',
-    ];
-    return unsupported.every((key) => options[key] === undefined);
-}
-// Per-page storage for the most recently captured DOM click event data.
-// Reset to null before each instrumented click; set by the exposeFunction callback.
-const pendingClickData = new WeakMap();
-export function scrollIntoViewAsync(locator, options = {}) {
-    const { behavior = 'smooth', block = 'center', timeout = 5000, postScrollTimeout = 500, } = options;
-    return locator.evaluate((element, opts) => new Promise((resolve) => {
-        let settled = false;
-        const finish = () => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(fallback);
-            setTimeout(resolve, opts.postScrollTimeout);
-        };
-        const fallback = setTimeout(finish, opts.timeout);
-        // scrollend fires once the smooth-scroll animation completes (Chrome 114+).
-        // It captures scroll on any ancestor element via the capture phase.
-        window.addEventListener('scrollend', finish, {
-            capture: true,
-            once: true,
-        });
-        element.scrollIntoView({ behavior: opts.behavior, block: opts.block });
-        // If the element is already in the target position no scroll occurs and
-        // scrollend never fires. Detect this: if no scroll event appears within
-        // two animation frames the element was already in place.
-        let didScroll = false;
-        window.addEventListener('scroll', () => {
-            didScroll = true;
-        }, {
-            capture: true,
-            passive: true,
-            once: true,
-        });
-        requestAnimationFrame(() => requestAnimationFrame(() => {
-            if (!didScroll)
-                finish();
-        }));
-    }), { behavior, block, timeout, postScrollTimeout });
+function getRecordedInnerEventEndMs(event) {
+    if (event.type === 'focusChange') {
+        return Math.max(...(event.mouse ? [event.mouse.endMs] : []), ...(event.scroll ? [event.scroll.endMs] : []), ...(event.zoom ? [event.zoom.endMs] : []));
+    }
+    return event.endMs;
 }
-const CURSOR_STEP_MS = 1000 / 60;
-/**
- * Physically moves the mouse from its current tracked position to (targetX,
- * targetY) over `duration` ms using `easing`, then returns a FocusChangeEvent
- * whose startMs is `eventStartMs` (which may predate this call, e.g. when a
- * scroll consumed part of moveDuration).  When duration ≤ 0 the cursor is
- * snapped directly to the target with a single move call.
- * Always updates the internal mousePositions tracker.
- */
-async function animateMouseMove(page, mouseMoveInternal, targetX, targetY, duration, easing, eventStartMs, elementRect) {
-    if (duration > 0) {
-        const startPos = mousePositions.get(page) ?? { x: 0, y: 0 };
-        const steps = Math.max(1, Math.floor(duration / CURSOR_STEP_MS));
-        const stepMs = duration / steps;
-        for (let i = 0; i <= steps; i++) {
-            const t = i / steps;
-            const easedT = evaluateEasingAtT(t, easing);
-            const x = startPos.x + easedT * (targetX - startPos.x);
-            const y = startPos.y + easedT * (targetY - startPos.y);
-            await mouseMoveInternal(x, y);
-            if (i < steps) {
-                await new Promise((resolve) => setTimeout(resolve, stepMs));
+function resolveLocatorMouseAction(locator, interactionType) {
+    switch (interactionType) {
+        case 'click': {
+            const action = getOriginalLocatorClick(locator);
+            if (action)
+                return { doClick: action, supportsTrial: true };
+            break;
+        }
+        case 'tap': {
+            const action = getOriginalLocatorTap(locator);
+            if (action)
+                return { doClick: action, supportsTrial: true };
+            break;
+        }
+        case 'check': {
+            const action = getOriginalLocatorCheck(locator);
+            if (action)
+                return { doClick: action, supportsTrial: true };
+            break;
+        }
+        case 'uncheck': {
+            const action = getOriginalLocatorUncheck(locator);
+            if (action)
+                return { doClick: action, supportsTrial: true };
+            break;
+        }
+        case 'select': {
+            const action = getOriginalLocatorSelect(locator);
+            if (action) {
+                return {
+                    doClick: (options) => action(null, options).then(() => { }),
+                    supportsTrial: false,
+                };
             }
+            break;
+        }
+        default: {
+            const _ = interactionType;
+            throw new Error(`Unknown mouse click interaction type: ${_}`);
         }
     }
-    else {
-        await mouseMoveInternal(targetX, targetY);
-    }
-    mousePositions.set(page, { x: targetX, y: targetY });
-    const endMs = Date.now();
-    return {
-        type: 'focusChange',
-        startMs: eventStartMs,
-        endMs,
-        x: targetX,
-        y: targetY,
-        easing,
-        ...(elementRect !== undefined ? { elementRect } : {}),
-    };
-}
-function resolveMoveStartMs(scrollResult, fallbackStartMs) {
-    return scrollResult.shouldScrollBeforeMouseMove
-        ? scrollResult.scrollEndMs
-        : fallbackStartMs;
-}
-function resolveMoveDuration(scrollResult, resolvedDuration) {
-    return scrollResult.shouldScrollBeforeMouseMove
-        ? resolvedDuration
-        : Math.max(0, resolvedDuration - scrollResult.scrollElapsedMs);
+    throw new Error(`[screenci] Missing original locator action for '${interactionType}'.`);
 }
-/**
- * Performs all click mechanics (scroll-check, zoom handling, cursor animation,
- * click, post-click move) and returns the collected timing/position data.
- * Returns null if coordinates could not be determined (no DOM event and no
- * locator bounding box).
- */
-async function performClickActions(locator, doClick, clickOptions, autoZoomOptions, position, moveDuration, moveSpeed, beforeClickPause = CLICK_DURATION_MS / 2, moveEasing = 'ease-in-out', postClickPause = CLICK_DURATION_MS / 2, postClickMove) {
+async function performAction(mouseMoveRequest, locator, doClick, supportsTrial, mode, autoZoomOptions, position, beforeClickPause = 0, postClickPause = 0, postClickMove, shouldHideMouse = false) {
     const page = locator.page();
-    pendingClickData.set(page, null);
-    const halfClickDuration = CLICK_DURATION_MS / 2;
-    const mouseMoveInternal = originalMouseMoves.get(page) ?? page.mouse.move.bind(page.mouse);
-    const moveStartTime = Date.now();
-    const scrollResult = await new ZoomScrollHandler(autoZoomOptions).scroll(locator);
-    const { locatorRect, scrollElapsedMs } = scrollResult;
-    const isFirstAutoZoomEvent = scrollResult.isFirstAutoZoomInteraction;
-    if (!locatorRect) {
-        logger.warn('[screenci] Unable to get locator bounding box; skipping auto-scroll check.');
-    }
-    const innerEvents = [];
-    // If inside autoZoom: optionally await zoom duration for camera pan then
-    // update the zoom location tracker.
-    if (isInsideAutoZoom() && locatorRect) {
-        const targetX = position
-            ? locatorRect.x + position.x
-            : locatorRect.x + locatorRect.width / 2;
-        const targetY = position
-            ? locatorRect.y + position.y
-            : locatorRect.y + locatorRect.height / 2;
-        const lastLoc = getLastZoomLocation();
-        if (lastLoc !== null) {
-            const zoomDur = getZoomDuration() ?? 0;
-            if (zoomDur > 0) {
-                await sleep(zoomDur);
-            }
-        }
-        setLastZoomLocation({
-            x: targetX,
-            y: targetY,
-            elementRect: locatorRect,
-            eventType: 'click',
-        });
-    }
-    const targetPos = position
-        ? position
-        : locatorRect
+    const focusChange = await changeFocus(locator, autoZoomOptions, mouseMoveRequest);
+    const elementRect = focusChange.elementRect;
+    const innerEvents = [focusChange];
+    const targetPosition = position ??
+        (elementRect
             ? {
-                x: locatorRect.width / 2,
-                y: locatorRect.height / 2,
-            }
-            : undefined;
-    if (targetPos && locatorRect) {
-        const targetX = locatorRect.x + targetPos.x;
-        const targetY = locatorRect.y + targetPos.y;
-        const resolvedDuration = resolveMouseMoveDuration(page, targetX, targetY, {
-            duration: moveDuration,
-            speed: moveSpeed,
-            defaultDuration: 1000,
-            context: 'click move',
-        });
-        if (scrollElapsedMs > 0 && !scrollResult.shouldScrollBeforeMouseMove) {
-            await mouseMoveInternal(targetX, targetY);
-            mousePositions.set(page, { x: targetX, y: targetY });
-            const remainingDuration = Math.max(0, resolvedDuration - scrollElapsedMs);
-            if (remainingDuration > 0) {
-                await new Promise((resolve) => setTimeout(resolve, remainingDuration));
+                x: elementRect.width / 2,
+                y: elementRect.height / 2,
             }
-            const moveEndTime = Date.now();
-            innerEvents.push({
-                type: 'focusChange',
-                startMs: moveStartTime,
-                endMs: moveEndTime,
-                x: targetX,
-                y: targetY,
-                easing: moveEasing,
-                focusOnly: false,
-                elementRect: locatorRect,
-            });
-        }
-        else {
-            innerEvents.push(await animateMouseMove(page, mouseMoveInternal, targetX, targetY, resolveMoveDuration(scrollResult, resolvedDuration), moveEasing, resolveMoveStartMs(scrollResult, moveStartTime), locatorRect));
-        }
+            : undefined);
+    if (!elementRect || !targetPosition) {
+        throw new Error('[screenci] performAction requires an element rect and target position.');
     }
-    else {
-        assertDurationOrSpeed(moveDuration, moveSpeed, 'click move');
-        const remainingMs = Math.max(0, moveSpeed === undefined ? (moveDuration ?? 1000) : 0);
-        if (remainingMs > 0) {
-            await new Promise((resolve) => setTimeout(resolve, remainingMs));
-        }
-    }
-    const zoomDur = isInsideAutoZoom() && locatorRect ? (getZoomDuration() ?? 0) : 0;
-    const effectiveBeforeClickPause = isFirstAutoZoomEvent
-        ? Math.max(beforeClickPause, getPostZoomInOutDelay() ?? 0, zoomDur)
-        : Math.max(beforeClickPause, zoomDur);
-    await new Promise((resolve) => setTimeout(resolve, effectiveBeforeClickPause));
-    await new Promise((resolve) => setTimeout(resolve, halfClickDuration));
-    // Note click can take some time, but better to show it before than after
-    const clickTime = Date.now();
-    const mouseDownStart = clickTime - halfClickDuration;
-    innerEvents.push({
-        type: 'mouseDown',
-        startMs: mouseDownStart,
-        endMs: clickTime,
-        easing: 'ease-in-out',
-    });
-    if (scrollElapsedMs > 0 &&
-        targetPos &&
-        locatorRect &&
-        canUseDirectMouseClickAfterScroll(clickOptions)) {
-        const mouseClickOptions = {
-            ...(clickOptions?.button !== undefined
-                ? { button: clickOptions.button }
-                : {}),
-            ...(clickOptions?.clickCount !== undefined
-                ? { clickCount: clickOptions.clickCount }
-                : {}),
-        };
-        await page.mouse.down(mouseClickOptions);
-        if (clickOptions?.delay) {
-            await new Promise((resolve) => setTimeout(resolve, clickOptions.delay));
-        }
-        await page.mouse.up(mouseClickOptions);
-    }
-    else {
+    await sleep(beforeClickPause);
+    if (!mouseMoveRequest) {
         await doClick({
-            ...clickOptions,
-            ...(targetPos ? { position: targetPos } : {}),
+            ...(supportsTrial ? { trial: true } : {}),
+            ...(mode === 'singleDuring' ? { position: targetPosition } : {}),
         });
+        await sleep(postClickPause);
+        return {
+            elementRect,
+            innerEvents,
+        };
     }
-    const domClickData = pendingClickData.get(page);
-    if (domClickData) {
-        const lastMouseMoveIndex = innerEvents.findIndex((e) => e.type === 'focusChange' || e.type === 'mouseMove');
-        if (lastMouseMoveIndex !== -1) {
-            const existingMove = innerEvents[lastMouseMoveIndex];
-            if (existingMove?.type === 'focusChange' ||
-                existingMove?.type === 'mouseMove') {
-                innerEvents[lastMouseMoveIndex] = {
-                    ...existingMove,
-                    x: domClickData.x,
-                    y: domClickData.y,
-                    elementRect: domClickData.targetRect,
-                };
-            }
-        }
-        mousePositions.set(page, { x: domClickData.x, y: domClickData.y });
-    }
-    const mouseUpEnd = Date.now() + halfClickDuration;
-    innerEvents.push({
-        type: 'mouseUp',
-        startMs: clickTime,
-        endMs: mouseUpEnd,
-        easing: 'ease-in-out',
-    });
-    await new Promise((resolve) => setTimeout(resolve, halfClickDuration));
-    await new Promise((resolve) => setTimeout(resolve, postClickPause));
-    // Animate mouse cursor in the specified direction after the click completes,
-    // capturing start/end times and final position for the recorded event.
+    const clickActionBase = {
+        locator,
+        doClick,
+        supportsTrial,
+        targetX: elementRect.x + targetPosition.x,
+        targetY: elementRect.y + targetPosition.y,
+        clickOptions: { position: targetPosition },
+    };
+    const clickActionOptions = mode === 'singleDuring'
+        ? {
+            ...clickActionBase,
+            mode,
+        }
+        : {
+            ...clickActionBase,
+            mode,
+            shouldHideMouse,
+        };
+    const { events, elementRect: actionElementRect } = await performMouseClickAction(clickActionOptions);
+    innerEvents.push(...events);
+    await sleep(postClickPause);
     if (postClickMove !== undefined) {
-        const currentPos = mousePositions.get(page) ?? { x: 0, y: 0 };
+        const currentPos = getMousePosition(page) ?? { x: 0, y: 0 };
         let targetX;
         let targetY;
         if ('direction' in postClickMove) {
-            if (locatorRect === undefined) {
-                logger.warn('[screenci] postClickMove with direction requires a locator rect; skipping mouse move.');
-            }
-            else {
-                const padding = postClickMove.padding ?? 0;
-                switch (postClickMove.direction) {
-                    case 'up':
-                        targetX = currentPos.x;
-                        targetY = locatorRect.y - padding;
-                        break;
-                    case 'down':
-                        targetX = currentPos.x;
-                        targetY = locatorRect.y + locatorRect.height + padding;
-                        break;
-                    case 'left':
-                        targetX = locatorRect.x - padding;
-                        targetY = currentPos.y;
-                        break;
-                    case 'right':
-                        targetX = locatorRect.x + locatorRect.width + padding;
-                        targetY = currentPos.y;
-                        break;
-                    default: {
-                        const _ = postClickMove.direction;
-                        throw new Error(`Unknown postClickMove direction: ${_}`);
-                    }
+            const padding = postClickMove.padding ?? 0;
+            switch (postClickMove.direction) {
+                case 'up':
+                    targetX = currentPos.x;
+                    targetY = elementRect.y - padding;
+                    break;
+                case 'down':
+                    targetX = currentPos.x;
+                    targetY = elementRect.y + elementRect.height + padding;
+                    break;
+                case 'left':
+                    targetX = elementRect.x - padding;
+                    targetY = currentPos.y;
+                    break;
+                case 'right':
+                    targetX = elementRect.x + elementRect.width + padding;
+                    targetY = currentPos.y;
+                    break;
+                default: {
+                    const _ = postClickMove.direction;
+                    throw new Error(`Unknown postClickMove direction: ${_}`);
                 }
             }
         }
@@ -410,154 +183,33 @@ async function performClickActions(locator, doClick, clickOptions, autoZoomOptio
                 defaultDuration: undefined,
                 context: 'postClickMove',
             });
-            const steps = Math.max(1, Math.floor(duration / CURSOR_STEP_MS));
-            const stepMs = duration / steps;
-            const postClickMoveStartMs = Date.now();
-            const startPos = { ...currentPos };
-            for (let i = 0; i <= steps; i++) {
-                const t = i / steps;
-                const easedT = evaluateEasingAtT(t, easing);
-                const x = startPos.x + easedT * (targetX - startPos.x);
-                const y = startPos.y + easedT * (targetY - startPos.y);
-                await mouseMoveInternal(x, y);
-                if (i < steps) {
-                    await new Promise((resolve) => setTimeout(resolve, stepMs));
-                }
-            }
-            const postClickMoveEndMs = Date.now();
-            innerEvents.push({
-                type: 'focusChange',
-                startMs: postClickMoveStartMs,
-                endMs: postClickMoveEndMs,
-                x: targetX,
-                y: targetY,
+            const startMs = Date.now();
+            await performMouseMove({
+                page,
+                targetX,
+                targetY,
+                duration,
                 easing,
             });
-            mousePositions.set(page, { x: targetX, y: targetY });
-        }
-    }
-    let elementRect;
-    if (domClickData) {
-        elementRect = domClickData.targetRect;
-    }
-    else if (locatorRect) {
-        elementRect = locatorRect ?? undefined;
-    }
-    if (elementRect) {
-        return {
-            elementRect,
-            innerEvents,
-        };
-    }
-    else {
-        logger.warn('[screenci] Failed to capture click coordinates from both DOM event and locator bounding box.');
-        return null;
-    }
-}
-async function prepareAutoZoomForLocator(locator, eventType, autoZoomOptions) {
-    const scrollHandler = new ZoomScrollHandler(autoZoomOptions);
-    const zoomDur = scrollHandler.isInsideAutoZoom ? (getZoomDuration() ?? 0) : 0;
-    if (scrollHandler.isInsideAutoZoom &&
-        scrollHandler.hadPreviousZoomLocation &&
-        zoomDur > 0) {
-        await sleep(zoomDur);
-    }
-    const { locatorRect, isFirstAutoZoomInteraction } = await scrollHandler.scroll(locator);
-    if (scrollHandler.isInsideAutoZoom && locatorRect) {
-        if (isFirstAutoZoomInteraction && zoomDur > 0) {
-            await sleep(zoomDur);
-        }
-        setLastZoomLocation({
-            x: locatorRect.x + locatorRect.width / 2,
-            y: locatorRect.y + locatorRect.height / 2,
-            elementRect: locatorRect,
-            eventType,
-        });
-    }
-    return { locatorRect, isFirstAutoZoomInteraction };
-}
-async function performSimpleAction(locator, doAction, options, subType, clickOpt, autoZoomOptions, position, recordMousePress = subType === 'tap') {
-    await sleep(PRE_ACTION_SLEEP);
-    let innerEvents = [];
-    let elementRect;
-    if (clickOpt !== undefined) {
-        const { moveDuration, moveSpeed, beforeClickPause, moveEasing, postClickPause, postClickMove, } = clickOpt;
-        const clickActionResult = await performClickActions(locator, doAction, {}, autoZoomOptions, position, moveDuration, moveSpeed, beforeClickPause, moveEasing, postClickPause, postClickMove);
-        innerEvents = clickActionResult?.innerEvents ?? [];
-        elementRect = clickActionResult?.elementRect;
-    }
-    else {
-        const locatorRect = await locator.boundingBox();
-        if (isInsideAutoZoom() && locatorRect) {
-            const focusStart = Date.now();
-            const zoomDur = getZoomDuration() ?? 0;
-            if (zoomDur > 0)
-                await sleep(zoomDur);
-            const focusEnd = Date.now();
+            const endMs = Date.now();
             innerEvents.push({
                 type: 'focusChange',
-                startMs: focusStart,
-                endMs: focusEnd,
-                x: locatorRect.x + locatorRect.width / 2,
-                y: locatorRect.y + locatorRect.height / 2,
-                easing: getZoomEasing() ?? 'ease-in-out',
-                focusOnly: true,
-                elementRect: locatorRect,
-            });
-        }
-        const targetPosition = locatorRect
-            ? {
-                x: locatorRect.width / 2,
-                y: locatorRect.height / 2,
-            }
-            : undefined;
-        const startTime = Date.now();
-        await doAction({
-            ...options,
-            ...(targetPosition ? { position: targetPosition } : {}),
-        });
-        const endTime = Date.now();
-        elementRect = locatorRect ?? undefined;
-        if (recordMousePress) {
-            const midTime = (startTime + endTime) / 2;
-            innerEvents.push({
-                type: 'mouseDown',
-                startMs: startTime,
-                endMs: midTime,
-            });
-            innerEvents.push({
-                type: 'mouseUp',
-                startMs: midTime,
-                endMs: endTime,
+                x: targetX,
+                y: targetY,
+                startMs,
+                endMs,
+                mouse: {
+                    startMs,
+                    endMs,
+                    ...(duration > 0 ? { easing } : {}),
+                },
             });
         }
     }
-    const simpleWaitStart = Date.now();
-    await sleep(POST_ACTION_SLEEP);
-    const simpleWaitEnd = Date.now();
-    innerEvents.push({
-        type: 'mouseWait',
-        startMs: simpleWaitStart,
-        endMs: simpleWaitEnd,
-    });
-    if (activeClickRecorder && innerEvents.length > 0) {
-        activeClickRecorder.addInput(subType, elementRect, innerEvents);
-    }
-}
-async function recordedClick(locator, doClick, clickOptions, autoZoomOptions, position, moveDuration, moveSpeed, beforeClickPause = CLICK_DURATION_MS / 2, moveEasing = 'ease-in-out', postClickPause = CLICK_DURATION_MS / 2, postClickMove) {
-    await sleep(PRE_ACTION_SLEEP);
-    const result = await performClickActions(locator, doClick, clickOptions, autoZoomOptions, position, moveDuration, moveSpeed, beforeClickPause, moveEasing, postClickPause, postClickMove);
-    const clickWaitStart = Date.now();
-    await sleep(POST_ACTION_SLEEP);
-    const clickWaitEnd = Date.now();
-    if (activeClickRecorder && result) {
-        result.innerEvents.push({
-            type: 'mouseWait',
-            startMs: clickWaitStart,
-            endMs: clickWaitEnd,
-        });
-        activeClickRecorder.addInput('click', result.elementRect, result.innerEvents);
-    }
+    return {
+        elementRect: actionElementRect ?? elementRect,
+        innerEvents,
+    };
 }
 function instrumentLocatorMethods(obj) {
     for (const method of LOCATOR_RETURN_METHODS) {
@@ -585,6 +237,7 @@ export function instrumentLocator(locator) {
         return locator;
     instrumented.add(locator);
     const originalClick = locator.click.bind(locator);
+    setOriginalLocatorClick(locator, originalClick);
     locator.click = async (options) => {
         const { moveDuration, moveSpeed, beforeClickPause, moveEasing, postClickPause, postClickMove, autoZoomOptions, position, steps: _steps, ...clickOptions } = options ?? {};
         if (isInsideHide()) {
@@ -594,66 +247,36 @@ export function instrumentLocator(locator) {
             });
         }
         assertDurationOrSpeed(moveDuration, moveSpeed, 'click move');
-        return recordedClick(locator, (options) => originalClick(options), clickOptions, autoZoomOptions, position, moveDuration, moveSpeed, beforeClickPause, moveEasing, postClickPause, postClickMove);
+        const { doClick, supportsTrial } = resolveLocatorMouseAction(locator, 'click');
+        const result = await performAction({
+            ...(position !== undefined ? { targetPosInElement: position } : {}),
+            ...(moveDuration !== undefined ? { duration: moveDuration } : {}),
+            ...(moveSpeed !== undefined ? { speed: moveSpeed } : {}),
+            easing: moveEasing ?? 'ease-in-out',
+        }, locator, doClick, supportsTrial, 'singleDuring', autoZoomOptions, position, beforeClickPause, postClickPause, postClickMove, false);
+        if (activeClickRecorder && result) {
+            activeClickRecorder.addInput('click', undefined, result.innerEvents);
+        }
     };
     const originalPressSequentially = locator.pressSequentially.bind(locator);
     locator.pressSequentially = async (text, options) => {
+        const clickOpt = options?.click ?? {};
         const { click: _click, autoZoomOptions, hideMouse: _hideMouse, position: _position, ...pressOptions } = options ?? {};
         if (isInsideHide()) {
             return originalPressSequentially(text, pressOptions);
         }
-        await sleep(PRE_ACTION_SLEEP);
         const innerEvents = [];
-        let elementRect;
-        if (options?.click !== undefined) {
-            // Click before fill: performClickActions handles scrolling and bounding box.
-            const clickOpt = options.click;
-            const position = options.position;
-            const { moveDuration, moveSpeed, beforeClickPause, moveEasing, postClickPause, postClickMove, ...clickOptions } = clickOpt;
-            const clickActionResult = await performClickActions(locator, (options) => originalClick(options), clickOptions, options.autoZoomOptions, position, moveDuration, moveSpeed, beforeClickPause, moveEasing, postClickPause, postClickMove);
-            innerEvents.push(...(clickActionResult?.innerEvents ?? []));
-            elementRect = clickActionResult?.elementRect;
-        }
-        else {
-            const { locatorRect, isFirstAutoZoomInteraction } = await prepareAutoZoomForLocator(locator, 'fill', options?.autoZoomOptions);
-            if (isFirstAutoZoomInteraction) {
-                const postDelay = getPostZoomInOutDelay() ?? 0;
-                if (postDelay > 0)
-                    await sleep(postDelay);
-            }
-            elementRect = locatorRect;
-            if (isInsideAutoZoom() && locatorRect) {
-                const zoomDur = getZoomDuration() ?? 0;
-                if (zoomDur > 0) {
-                    await sleep(zoomDur);
-                }
-            }
-        }
-        // Hide cursor while typing (will be shown again on next mouse move)
-        const page = locator.page();
-        const shouldHideMouse = options?.hideMouse === true;
-        if (shouldHideMouse) {
-            const cursorVisible = mouseVisibilities.get(page) ?? true;
-            if (cursorVisible) {
-                mouseVisibilities.set(page, false);
-                const hideMs = Date.now();
-                innerEvents.push({
-                    type: 'mouseHide',
-                    startMs: hideMs,
-                    endMs: hideMs,
-                });
-            }
-        }
-        await originalPressSequentially(text, pressOptions);
-        const pressWaitStart = Date.now();
-        await sleep(POST_ACTION_SLEEP);
-        const pressWaitEnd = Date.now();
+        let elementRect = undefined;
+        const { moveDuration, moveSpeed, beforeClickPause, moveEasing = 'ease-in-out', postClickPause, postClickMove, } = clickOpt;
+        const clickActionResult = await performAction({
+            targetPosInElement: options?.position ?? { x: 0, y: 0 },
+            ...(moveDuration !== undefined ? { duration: moveDuration } : {}),
+            ...(moveSpeed !== undefined ? { speed: moveSpeed } : {}),
+            easing: moveEasing,
+        }, locator, async () => originalPressSequentially(text, pressOptions), false, 'singleBefore', autoZoomOptions, options?.position, beforeClickPause ?? CLICK_DURATION_MS / 2, postClickPause ?? CLICK_DURATION_MS / 2, postClickMove, true);
+        innerEvents.push(...(clickActionResult?.innerEvents ?? []));
+        elementRect = clickActionResult?.elementRect;
         if (activeClickRecorder) {
-            innerEvents.push({
-                type: 'mouseWait',
-                startMs: pressWaitStart,
-                endMs: pressWaitEnd,
-            });
             activeClickRecorder.addInput('pressSequentially', elementRect, innerEvents);
         }
     };
@@ -663,112 +286,16 @@ export function instrumentLocator(locator) {
             const { duration: _duration, click: _click, position: _position, hideMouse: _hideMouse, autoZoomOptions: _autoZoomOptions, ...fillOptions } = options ?? {};
             return originalFill(value, fillOptions);
         }
-        if (options?.click !== undefined) {
-            await sleep(PRE_ACTION_SLEEP);
-            const clickActionResult = await performClickActions(locator, (clickOptions) => originalClick(clickOptions), {}, options.autoZoomOptions, options.position, options.click.moveDuration, options.click.moveSpeed, options.click.beforeClickPause, options.click.moveEasing, options.click.postClickPause, options.click.postClickMove);
-            const innerEvents = [...(clickActionResult?.innerEvents ?? [])];
-            const elementRect = clickActionResult?.elementRect;
-            const page = locator.page();
-            if (options.hideMouse === true) {
-                const cursorVisible = mouseVisibilities.get(page) ?? true;
-                if (cursorVisible) {
-                    mouseVisibilities.set(page, false);
-                    const hideMs = Date.now();
-                    innerEvents.push({
-                        type: 'mouseHide',
-                        startMs: hideMs,
-                        endMs: hideMs,
-                    });
-                }
-            }
-            await locator.evaluate((element) => {
-                if (element instanceof HTMLInputElement ||
-                    element instanceof HTMLTextAreaElement) {
-                    element.focus();
-                    element.select();
-                    return;
-                }
-                if (element instanceof HTMLElement && element.isContentEditable) {
-                    element.focus();
-                    const selection = element.ownerDocument.getSelection();
-                    if (!selection)
-                        return;
-                    const range = element.ownerDocument.createRange();
-                    range.selectNodeContents(element);
-                    selection.removeAllRanges();
-                    selection.addRange(range);
-                }
-            });
-            const duration = options.duration ?? 1000;
-            const delay = value.length > 0 ? duration / value.length : 0;
-            await page.keyboard.type(value, { delay });
-            const fillWaitStart = Date.now();
-            await sleep(POST_ACTION_SLEEP);
-            const fillWaitEnd = Date.now();
-            innerEvents.push({
-                type: 'mouseWait',
-                startMs: fillWaitStart,
-                endMs: fillWaitEnd,
-            });
-            if (activeClickRecorder) {
-                activeClickRecorder.addInput('pressSequentially', elementRect, innerEvents);
-            }
-            return;
-        }
-        await sleep(PRE_ACTION_SLEEP);
-        const page = locator.page();
+        const clickOpt = options?.click ?? {};
         const innerEvents = [];
-        const fillOptions = options ?? {};
-        const locatorRect = await locator.boundingBox();
-        let elementRect = locatorRect ?? undefined;
-        if (fillOptions.hideMouse === true) {
-            const cursorVisible = mouseVisibilities.get(page) ?? true;
-            if (cursorVisible) {
-                mouseVisibilities.set(page, false);
-                const hideMs = Date.now();
-                innerEvents.push({
-                    type: 'mouseHide',
-                    startMs: hideMs,
-                    endMs: hideMs,
-                });
-            }
-        }
-        if (isInsideAutoZoom() && locatorRect) {
-            const correctedScrollResult = await new ZoomScrollHandler(options?.autoZoomOptions).scroll(locator);
-            const correctedRect = correctedScrollResult.locatorRect ?? locatorRect;
-            const focusStart = Date.now();
-            await locator.evaluate((element) => {
-                if (element instanceof HTMLInputElement ||
-                    element instanceof HTMLTextAreaElement) {
-                    element.focus();
-                    element.select();
-                    return;
-                }
-                if (element instanceof HTMLElement && element.isContentEditable) {
-                    element.focus();
-                    const selection = element.ownerDocument.getSelection();
-                    if (!selection)
-                        return;
-                    const range = element.ownerDocument.createRange();
-                    range.selectNodeContents(element);
-                    selection.removeAllRanges();
-                    selection.addRange(range);
-                }
-            });
-            const focusEnd = Date.now();
-            innerEvents.push({
-                type: 'focusChange',
-                startMs: focusStart,
-                endMs: focusEnd,
-                x: correctedRect.x + correctedRect.width / 2,
-                y: correctedRect.y + correctedRect.height / 2,
-                easing: getZoomEasing() ?? 'ease-in-out',
-                focusOnly: true,
-                elementRect: correctedRect,
-            });
-            elementRect = correctedRect;
-        }
-        else {
+        let elementRect = undefined;
+        const { moveDuration, moveSpeed, beforeClickPause, moveEasing = 'ease-in-out', postClickPause, postClickMove, } = clickOpt;
+        const clickActionResult = await performAction({
+            targetPosInElement: options?.position ?? { x: 0, y: 0 },
+            ...(moveDuration !== undefined ? { duration: moveDuration } : {}),
+            ...(moveSpeed !== undefined ? { speed: moveSpeed } : {}),
+            easing: moveEasing,
+        }, locator, async () => {
             await locator.evaluate((element) => {
                 if (element instanceof HTMLInputElement ||
                     element instanceof HTMLTextAreaElement) {
@@ -787,31 +314,43 @@ export function instrumentLocator(locator) {
                     selection.addRange(range);
                 }
             });
-        }
-        const duration = fillOptions.duration ?? 1000;
-        const delay = value.length > 0 ? duration / value.length : 0;
-        await page.keyboard.type(value, { delay });
-        const fillWaitStart = Date.now();
-        await sleep(POST_ACTION_SLEEP);
-        const fillWaitEnd = Date.now();
-        innerEvents.push({
-            type: 'mouseWait',
-            startMs: fillWaitStart,
-            endMs: fillWaitEnd,
-        });
-        if (activeClickRecorder &&
-            (isInsideAutoZoom() || fillOptions.hideMouse === true)) {
+            const duration = options?.duration ?? 1000;
+            const delay = value.length > 0 ? duration / value.length : 0;
+            await locator.page().keyboard.type(value, { delay });
+        }, false, 'singleBefore', options?.autoZoomOptions, options?.position, beforeClickPause ?? CLICK_DURATION_MS / 2, postClickPause ?? CLICK_DURATION_MS / 2, postClickMove, true);
+        innerEvents.push(...(clickActionResult?.innerEvents ?? []));
+        elementRect = clickActionResult?.elementRect;
+        if (activeClickRecorder) {
             activeClickRecorder.addInput('pressSequentially', elementRect, innerEvents);
         }
-        return;
     };
     const originalTap = locator.tap.bind(locator);
+    setOriginalLocatorTap(locator, originalTap);
     locator.tap = async (options) => {
         const clickOpt = options?.click;
         const { click: _click, position, autoZoomOptions, ...tapOpts } = options ?? {};
-        return performSimpleAction(locator, (options) => originalTap(options), tapOpts, 'tap', clickOpt, autoZoomOptions, position);
+        if (isInsideHide()) {
+            return originalTap(tapOpts);
+        }
+        const { doClick, supportsTrial } = resolveLocatorMouseAction(locator, 'tap');
+        const result = await performAction(clickOpt
+            ? {
+                targetPosInElement: position ?? { x: 0, y: 0 },
+                ...(clickOpt.moveDuration !== undefined
+                    ? { duration: clickOpt.moveDuration }
+                    : {}),
+                ...(clickOpt.moveSpeed !== undefined
+                    ? { speed: clickOpt.moveSpeed }
+                    : {}),
+                easing: clickOpt.moveEasing ?? 'ease-in-out',
+            }
+            : undefined, locator, doClick, supportsTrial, 'singleDuring', autoZoomOptions, position, clickOpt?.beforeClickPause, clickOpt?.postClickPause, clickOpt?.postClickMove, false);
+        if (activeClickRecorder && result) {
+            activeClickRecorder.addInput('tap', result.elementRect, result.innerEvents);
+        }
     };
     const originalCheck = locator.check.bind(locator);
+    setOriginalLocatorCheck(locator, originalCheck);
     locator.check = async (options) => {
         const clickOpt = options?.click;
         const position = options?.position;
@@ -819,9 +358,25 @@ export function instrumentLocator(locator) {
         if (isInsideHide()) {
             return originalCheck(checkOpts);
         }
-        return performSimpleAction(locator, (options) => originalCheck(options), checkOpts, 'check', clickOpt, autoZoomOptions, position, false);
+        const { doClick, supportsTrial } = resolveLocatorMouseAction(locator, 'check');
+        const result = await performAction(clickOpt
+            ? {
+                targetPosInElement: position ?? { x: 0, y: 0 },
+                ...(clickOpt.moveDuration !== undefined
+                    ? { duration: clickOpt.moveDuration }
+                    : {}),
+                ...(clickOpt.moveSpeed !== undefined
+                    ? { speed: clickOpt.moveSpeed }
+                    : {}),
+                easing: clickOpt.moveEasing ?? 'ease-in-out',
+            }
+            : undefined, locator, doClick, supportsTrial, 'singleDuring', autoZoomOptions, position, clickOpt?.beforeClickPause, clickOpt?.postClickPause, clickOpt?.postClickMove, false);
+        if (activeClickRecorder && result) {
+            activeClickRecorder.addInput('check', result.elementRect, result.innerEvents);
+        }
     };
     const originalUncheck = locator.uncheck.bind(locator);
+    setOriginalLocatorUncheck(locator, originalUncheck);
     locator.uncheck = async (options) => {
         const clickOpt = options?.click;
         const position = options?.position;
@@ -829,7 +384,22 @@ export function instrumentLocator(locator) {
         if (isInsideHide()) {
             return originalUncheck(uncheckOpts);
         }
-        return performSimpleAction(locator, (options) => originalUncheck(options), uncheckOpts, 'uncheck', clickOpt, autoZoomOptions, position, false);
+        const { doClick, supportsTrial } = resolveLocatorMouseAction(locator, 'uncheck');
+        const result = await performAction(clickOpt
+            ? {
+                targetPosInElement: position ?? { x: 0, y: 0 },
+                ...(clickOpt.moveDuration !== undefined
+                    ? { duration: clickOpt.moveDuration }
+                    : {}),
+                ...(clickOpt.moveSpeed !== undefined
+                    ? { speed: clickOpt.moveSpeed }
+                    : {}),
+                easing: clickOpt.moveEasing ?? 'ease-in-out',
+            }
+            : undefined, locator, doClick, supportsTrial, 'singleDuring', autoZoomOptions, position, clickOpt?.beforeClickPause, clickOpt?.postClickPause, clickOpt?.postClickMove, false);
+        if (activeClickRecorder && result) {
+            activeClickRecorder.addInput('uncheck', result.elementRect, result.innerEvents);
+        }
     };
     locator.setChecked = async (checked, options) => {
         if (checked) {
@@ -840,47 +410,61 @@ export function instrumentLocator(locator) {
         }
     };
     const originalSelectOption = locator.selectOption.bind(locator);
+    let currentSelectValues = null;
+    let currentSelectOptions;
+    let currentSelectResult = [];
+    setOriginalLocatorSelect(locator, (_values, actionOptions) => originalSelectOption(currentSelectValues, {
+        ...currentSelectOptions,
+        ...actionOptions,
+    }).then((res) => {
+        currentSelectResult = res;
+        return res;
+    }));
     locator.selectOption = async (values, options) => {
         const clickOpt = options?.click;
         const { click: _click, position, autoZoomOptions, ...selectOpts } = options ?? {};
         if (isInsideHide()) {
             return originalSelectOption(values, selectOpts);
         }
-        let result = [];
-        await performSimpleAction(locator, (options) => originalSelectOption(values, options).then((res) => {
-            result = res;
-        }), selectOpts, 'select', clickOpt, autoZoomOptions, position, false);
-        return result;
+        currentSelectValues = values;
+        currentSelectOptions = selectOpts;
+        currentSelectResult = [];
+        const { doClick, supportsTrial } = resolveLocatorMouseAction(locator, 'select');
+        const actionResult = await performAction(clickOpt
+            ? {
+                targetPosInElement: position ?? { x: 0, y: 0 },
+                ...(clickOpt.moveDuration !== undefined
+                    ? { duration: clickOpt.moveDuration }
+                    : {}),
+                ...(clickOpt.moveSpeed !== undefined
+                    ? { speed: clickOpt.moveSpeed }
+                    : {}),
+                easing: clickOpt.moveEasing ?? 'ease-in-out',
+            }
+            : undefined, locator, doClick, supportsTrial, 'singleDuring', autoZoomOptions, position, clickOpt?.beforeClickPause, clickOpt?.postClickPause, clickOpt?.postClickMove);
+        if (activeClickRecorder && actionResult) {
+            activeClickRecorder.addInput('select', actionResult.elementRect, actionResult.innerEvents);
+        }
+        return currentSelectResult;
     };
     const originalHover = locator.hover.bind(locator);
     locator.hover = async (options) => {
         const { moveDuration, moveSpeed, easing: moveEasing = 'ease-in-out', hoverDuration = 1000, position, ...hoverOptions } = options ?? {};
         assertDurationOrSpeed(moveDuration, moveSpeed, 'hover move');
-        const page = locator.page();
-        const mouseMoveInternal = originalMouseMoves.get(page) ?? page.mouse.move.bind(page.mouse);
-        const moveStartTime = Date.now();
-        const scrollResult = await new ZoomScrollHandler().scroll(locator);
-        const { locatorRect } = scrollResult;
         const innerEvents = [];
-        const targetPos = position ??
-            (locatorRect
-                ? { x: locatorRect.width / 2, y: locatorRect.height / 2 }
-                : undefined);
-        if (targetPos && locatorRect) {
-            const targetX = locatorRect.x + targetPos.x;
-            const targetY = locatorRect.y + targetPos.y;
-            const resolvedDuration = resolveMouseMoveDuration(page, targetX, targetY, {
-                duration: moveDuration,
-                speed: moveSpeed,
-                defaultDuration: 1000,
-                context: 'hover move',
-            });
-            innerEvents.push(await animateMouseMove(page, mouseMoveInternal, targetX, targetY, resolveMoveDuration(scrollResult, resolvedDuration), moveEasing, resolveMoveStartMs(scrollResult, moveStartTime), locatorRect));
-        }
+        const mouseMovePlan = {
+            targetPosInElement: position,
+            ...(moveDuration !== undefined ? { duration: moveDuration } : {}),
+            ...(moveSpeed !== undefined ? { speed: moveSpeed } : {}),
+            easing: moveEasing,
+        };
+        const hoverFocusChange = await changeFocus(locator, options?.autoZoomOptions, mouseMovePlan);
+        const locatorRect = hoverFocusChange.elementRect;
+        innerEvents.push(hoverFocusChange);
         const waitStartMs = Date.now();
         await originalHover({
             ...hoverOptions,
-            ...(targetPos ? { position: targetPos } : {}),
+            ...(position ? { position } : {}),
         });
         if (hoverDuration > 0) {
             await sleep(hoverDuration);
@@ -895,55 +479,38 @@ export function instrumentLocator(locator) {
             activeClickRecorder.addInput('hover', locatorRect, innerEvents);
         }
     };
+    const originalScrollIntoViewIfNeeded = locator.scrollIntoViewIfNeeded.bind(locator);
+    locator.scrollIntoViewIfNeeded = async (options) => {
+        if (isInsideHide()) {
+            return originalScrollIntoViewIfNeeded(options);
+        }
+        const { easing = 'ease-in-out', duration, amount, centering, } = options ?? {};
+        const result = await changeFocus(locator, {
+            easing,
+            ...(duration !== undefined ? { duration } : {}),
+            ...(amount !== undefined ? { amount } : {}),
+            ...(centering !== undefined ? { centering } : {}),
+        });
+        if (activeClickRecorder) {
+            activeClickRecorder.addInput('focusChange', result.elementRect, [result]);
+        }
+    };
     const originalSelectText = locator.selectText.bind(locator);
     locator.selectText = async (options) => {
-        const { moveDuration, moveSpeed, easing: moveEasing = 'ease-in-out', beforeClickPause = CLICK_DURATION_MS / 2, selectDuration = 600, ...selectOpts } = options ?? {};
+        const { moveDuration, moveSpeed, easing: moveEasing = 'ease-in-out', beforeClickPause = CLICK_DURATION_MS / 2, ...selectOpts } = options ?? {};
         assertDurationOrSpeed(moveDuration, moveSpeed, 'selectText move');
         const page = locator.page();
-        const mouseMoveInternal = originalMouseMoves.get(page) ?? page.mouse.move.bind(page.mouse);
-        const moveStartTime = Date.now();
-        const scrollResult = await new ZoomScrollHandler().scroll(locator);
-        const { locatorRect } = scrollResult;
         const innerEvents = [];
-        const targetPos = locatorRect
-            ? { x: locatorRect.width / 2, y: locatorRect.height / 2 }
-            : undefined;
-        if (targetPos && locatorRect) {
-            const targetX = locatorRect.x + targetPos.x;
-            const targetY = locatorRect.y + targetPos.y;
-            const resolvedDuration = resolveMouseMoveDuration(page, targetX, targetY, {
-                duration: moveDuration,
-                speed: moveSpeed,
-                defaultDuration: 1000,
-                context: 'selectText move',
-            });
-            innerEvents.push(await animateMouseMove(page, mouseMoveInternal, targetX, targetY, resolveMoveDuration(scrollResult, resolvedDuration), moveEasing, resolveMoveStartMs(scrollResult, moveStartTime), locatorRect));
-        }
-        await sleep(beforeClickPause);
-        await originalSelectText(selectOpts);
-        // Backtrack triple-click events from the moment originalSelectText resolves.
-        // Clamp start so events don't precede the prior animation (produces a visible
-        // pre-click pause in the recording, which is acceptable).
-        // All timestamps use a single base + integer * segmentMs to avoid FP drift.
-        const selectEndMs = Date.now();
-        const lastEventEndMs = innerEvents.at(-1)?.endMs ?? 0;
-        const tripleClickStartMs = Math.max(lastEventEndMs, selectEndMs - selectDuration);
-        const segmentMs = selectDuration / 6;
-        for (let i = 0; i < 3; i++) {
-            const seg = i * 2;
-            innerEvents.push({
-                type: 'mouseDown',
-                startMs: tripleClickStartMs + seg * segmentMs,
-                endMs: tripleClickStartMs + (seg + 1) * segmentMs,
-                easing: 'ease-in-out',
-            });
-            innerEvents.push({
-                type: 'mouseUp',
-                startMs: tripleClickStartMs + (seg + 1) * segmentMs,
-                endMs: tripleClickStartMs + (seg + 2) * segmentMs,
-                easing: 'ease-in-out',
-            });
-        }
+        const selectActionResult = await performAction({
+            targetPosInElement: { x: 0, y: 0 },
+            ...(moveDuration !== undefined ? { duration: moveDuration } : {}),
+            ...(moveSpeed !== undefined ? { speed: moveSpeed } : {}),
+            easing: moveEasing,
+        }, locator, async () => {
+            await originalSelectText(selectOpts);
+        }, false, 'tripleBefore', undefined, undefined, beforeClickPause, undefined, undefined, false);
+        const locatorRect = selectActionResult?.elementRect;
+        innerEvents.push(...(selectActionResult?.innerEvents ?? []));
         if (activeClickRecorder && innerEvents.length > 0) {
             activeClickRecorder.addInput('selectText', locatorRect, innerEvents);
         }
@@ -952,12 +519,8 @@ export function instrumentLocator(locator) {
         const { moveDuration, moveSpeed, moveEasing = 'ease-in-out', preDragPause = CLICK_DURATION_MS / 2, dragDuration, dragSpeed, dragEasing = 'ease-in-out', sourcePosition, targetPosition, } = options ?? {};
         assertDurationOrSpeed(moveDuration, moveSpeed, 'dragTo move');
         assertDurationOrSpeed(dragDuration, dragSpeed, 'dragTo drag');
-        await sleep(PRE_ACTION_SLEEP);
         const page = locator.page();
-        const mouseMoveInternal = originalMouseMoves.get(page) ?? page.mouse.move.bind(page.mouse);
-        const moveStartTime = Date.now();
-        const scrollResult = await new ZoomScrollHandler().scroll(locator);
-        const { locatorRect: sourceRect } = scrollResult;
+        const sourceRectPreview = await locator.boundingBox();
         const targetBb = await target.boundingBox();
         const targetRect = targetBb
             ? {
@@ -968,37 +531,31 @@ export function instrumentLocator(locator) {
             }
             : undefined;
         const innerEvents = [];
-        const sourcePos = sourcePosition ??
-            (sourceRect
-                ? { x: sourceRect.width / 2, y: sourceRect.height / 2 }
-                : undefined);
         const targetPos = targetPosition ??
             (targetRect
                 ? { x: targetRect.width / 2, y: targetRect.height / 2 }
                 : undefined);
-        // 1. Animate cursor to source
-        if (sourcePos && sourceRect) {
-            const toX = sourceRect.x + sourcePos.x;
-            const toY = sourceRect.y + sourcePos.y;
-            const resolvedDuration = resolveMouseMoveDuration(page, toX, toY, {
-                duration: moveDuration,
-                speed: moveSpeed,
-                defaultDuration: 1000,
-                context: 'dragTo move',
-            });
-            innerEvents.push(await animateMouseMove(page, mouseMoveInternal, toX, toY, resolveMoveDuration(scrollResult, resolvedDuration), moveEasing, resolveMoveStartMs(scrollResult, moveStartTime), sourceRect));
+        const sourceFocusChange = await changeFocus(locator, undefined, {
+            targetPosInElement: sourcePosition,
+            ...(moveDuration !== undefined ? { duration: moveDuration } : {}),
+            ...(moveSpeed !== undefined ? { speed: moveSpeed } : {}),
+            easing: moveEasing,
+        });
+        if (sourceFocusChange.elementRect) {
+            innerEvents.push(sourceFocusChange);
         }
         // 2. preDragPause + mouseDown
         await sleep(preDragPause);
         const mouseDownStart = Date.now();
-        await page.mouse.down();
+        await performMouseDown({
+            mouseDownInternal: getOriginalMouseDown(page, page.mouse.down.bind(page.mouse)),
+        });
         await sleep(CLICK_DURATION_MS / 2);
-        innerEvents.push({
-            type: 'mouseDown',
+        innerEvents.push(buildMouseDownEvent({
             startMs: mouseDownStart,
             endMs: Date.now(),
             easing: 'ease-in-out',
-        });
+        }));
         // 3. Drag: animate cursor from source to target
         const dragStartTime = Date.now();
         if (targetPos && targetRect) {
@@ -1010,28 +567,36 @@ export function instrumentLocator(locator) {
                 defaultDuration: 1000,
                 context: 'dragTo drag',
             });
-            innerEvents.push(await animateMouseMove(page, mouseMoveInternal, toX, toY, resolvedDuration, dragEasing, dragStartTime, targetRect));
+            await performMouseMove({
+                page,
+                targetX: toX,
+                targetY: toY,
+                duration: resolvedDuration,
+                easing: dragEasing,
+            });
+            innerEvents.push({
+                type: 'mouseMove',
+                startMs: dragStartTime,
+                endMs: Date.now(),
+                x: toX,
+                y: toY,
+                ...(resolvedDuration > 0 ? { easing: dragEasing } : {}),
+                elementRect: targetRect,
+            });
         }
         // 4. mouseUp at target
         const mouseUpStart = Date.now();
-        await page.mouse.up();
+        await performMouseUp({
+            mouseUpInternal: getOriginalMouseUp(page, page.mouse.up.bind(page.mouse)),
+        });
         await sleep(CLICK_DURATION_MS / 2);
-        innerEvents.push({
-            type: 'mouseUp',
+        innerEvents.push(buildMouseUpEvent({
             startMs: mouseUpStart,
             endMs: Date.now(),
             easing: 'ease-in-out',
-        });
-        const dragWaitStart = Date.now();
-        await sleep(POST_ACTION_SLEEP);
-        const dragWaitEnd = Date.now();
-        innerEvents.push({
-            type: 'mouseWait',
-            startMs: dragWaitStart,
-            endMs: dragWaitEnd,
-        });
+        }));
         if (activeClickRecorder && innerEvents.length > 0) {
-            activeClickRecorder.addInput('dragTo', sourceRect, innerEvents);
+            activeClickRecorder.addInput('dragTo', sourceFocusChange.elementRect, innerEvents);
         }
     };
     const originalPage = locator.page.bind(locator);
@@ -1057,23 +622,6 @@ export async function instrumentPage(page) {
     if (instrumented.has(page))
         return page;
     instrumented.add(page);
-    // Expose a Node.js function to the browser that captures DOM click event data.
-    // Called synchronously from the click handler before any navigation can occur.
-    await page.exposeFunction('__screenciOnClick', (data) => {
-        pendingClickData.set(page, data);
-    });
-    // Inject a capture listener on every page load (including after navigation).
-    await page.addInitScript(() => {
-        document.addEventListener('click', (e) => {
-            const target = e.target;
-            const r = target.getBoundingClientRect();
-            window.__screenciOnClick({
-                x: e.clientX,
-                y: e.clientY,
-                targetRect: { x: r.x, y: r.y, width: r.width, height: r.height },
-            });
-        }, { capture: true });
-    });
     instrumentLocatorMethods(page);
     const originalPageFrameLocator = page.frameLocator.bind(page);
     page.frameLocator = (...args) => instrumentFrameLocator(originalPageFrameLocator(...args));
@@ -1085,7 +633,35 @@ export async function instrumentPage(page) {
     // Instrument page.mouse to record mouse moves and visibility toggles.
     const originalMouse = page.mouse;
     const originalMove = originalMouse.move.bind(originalMouse);
-    originalMouseMoves.set(page, originalMove);
+    const originalDown = originalMouse.down.bind(originalMouse);
+    const originalUp = originalMouse.up.bind(originalMouse);
+    const originalClickMethod = originalMouse.click;
+    const originalClick = typeof originalClickMethod === 'function'
+        ? originalClickMethod.bind(originalMouse)
+        : async (x, y, options) => {
+            await originalMove(x, y);
+            await originalDown(options);
+            if (options?.delay) {
+                await sleep(options.delay);
+            }
+            await originalUp(options);
+        };
+    const originalShowMethod = originalMouse
+        .show;
+    const originalHideMethod = originalMouse
+        .hide;
+    const originalShow = typeof originalShowMethod === 'function'
+        ? originalShowMethod.bind(originalMouse)
+        : () => { };
+    const originalHide = typeof originalHideMethod === 'function'
+        ? originalHideMethod.bind(originalMouse)
+        : () => { };
+    setOriginalMouseMove(page, originalMove);
+    setOriginalMouseClick(page, originalClick);
+    setOriginalMouseDown(page, originalDown);
+    setOriginalMouseUp(page, originalUp);
+    setOriginalMouseShow(page, originalShow);
+    setOriginalMouseHide(page, originalHide);
     originalMouse.move = async (x, y, options) => {
         const duration = resolveMouseMoveDuration(page, x, y, {
             duration: options?.duration,
@@ -1095,30 +671,29 @@ export async function instrumentPage(page) {
         });
         const easing = options?.easing ?? 'ease-in-out';
         const startMs = Date.now();
-        if (duration > 0) {
-            const startPos = mousePositions.get(page) ?? { x: 0, y: 0 };
-            const steps = Math.max(1, Math.floor(duration / CURSOR_STEP_MS));
-            const stepMs = duration / steps;
-            for (let i = 0; i <= steps; i++) {
-                const t = i / steps;
-                const easedT = evaluateEasingAtT(t, easing);
-                const cx = startPos.x + easedT * (x - startPos.x);
-                const cy = startPos.y + easedT * (y - startPos.y);
-                await originalMove(cx, cy);
-                if (i < steps) {
-                    await new Promise((resolve) => setTimeout(resolve, stepMs));
-                }
-            }
-        }
-        else {
-            await originalMove(x, y);
-        }
-        mousePositions.set(page, { x, y });
-        const endMs = Date.now();
+        await performMouseMove({
+            page,
+            targetX: x,
+            targetY: y,
+            duration,
+            easing,
+        });
+        const moveEvent = {
+            type: 'focusChange',
+            startMs,
+            endMs: Date.now(),
+            x,
+            y,
+            mouse: {
+                startMs,
+                endMs: Date.now(),
+                ...(duration > 0 ? { easing } : {}),
+            },
+        };
         if (activeClickRecorder) {
             // Auto-show cursor when moving after a typing auto-hide
-            if (!(mouseVisibilities.get(page) ?? true)) {
-                mouseVisibilities.set(page, true);
+            if (!isMouseVisible(page)) {
+                setMouseVisible(page, true);
                 const showMs = startMs;
                 const showEvent = {
                     type: 'mouseShow',
@@ -1127,21 +702,16 @@ export async function instrumentPage(page) {
                 };
                 activeClickRecorder.addInput('mouseShow', undefined, [showEvent]);
             }
-            const moveEvent = {
-                type: 'focusChange',
-                startMs,
-                endMs,
-                x,
-                y,
-                ...(duration > 0 ? { easing } : {}),
-            };
             activeClickRecorder.addInput('focusChange', undefined, [moveEvent]);
         }
     };
-    mouseVisibilities.set(page, true);
+    setMouseVisible(page, true);
     originalMouse.show = () => {
-        if (!(mouseVisibilities.get(page) ?? true)) {
-            mouseVisibilities.set(page, true);
+        if (!isMouseVisible(page)) {
+            performMouseShow({
+                mouseShowInternal: getOriginalMouseShow(page, originalShow),
+                page,
+            });
             if (activeClickRecorder) {
                 const timeMs = Date.now();
                 const showEvent = {
@@ -1154,8 +724,11 @@ export async function instrumentPage(page) {
         }
     };
     originalMouse.hide = () => {
-        if (mouseVisibilities.get(page) ?? true) {
-            mouseVisibilities.set(page, false);
+        if (isMouseVisible(page)) {
+            performMouseHide({
+                mouseHideInternal: getOriginalMouseHide(page, originalHide),
+                page,
+            });
             if (activeClickRecorder) {
                 const timeMs = Date.now();
                 const hideEvent = {