donobu 5.60.4 → 5.60.6

package/dist/esm/lib/ai/locate/locateElement.js

@@ -13,6 +13,14 @@ const locateSchema_1 = require("./locateSchema");
 const DISAMBIGUATE_THRESHOLD = 5;
 /** Maximum outer HTML length per snippet shown during disambiguation. */
 const SNIPPET_MAX_CHARS = 200;
+/**
+ * Per-candidate read budget during disambiguation. Locator `evaluate`/
+ * `boundingBox` default to *no* timeout, so a candidate that detaches mid-loop
+ * would wait forever (the surrounding try/catch only traps errors, not hangs,
+ * and the AbortSignal isn't plumbed into these ops). Cap it and let a miss fall
+ * through to the placeholder snippet below.
+ */
+const CANDIDATE_READ_TIMEOUT_MILLIS = 1000;
 /**
  * Resolve a natural-language element description to a Playwright {@link Locator}.
  *
@@ -87,8 +95,10 @@ async function disambiguate(page, description, gptClient, locator, locateResult,
             const html = await nth.evaluate((el, max) => {
                 const raw = el.outerHTML;
                 return raw.length > max ? raw.slice(0, max) + '…' : raw;
-            }, SNIPPET_MAX_CHARS);
-            const box = await nth.boundingBox();
+            }, SNIPPET_MAX_CHARS, { timeout: CANDIDATE_READ_TIMEOUT_MILLIS });
+            const box = await nth.boundingBox({
+                timeout: CANDIDATE_READ_TIMEOUT_MILLIS,
+            });
             const pos = box
                 ? `(${Math.round(box.x)}, ${Math.round(box.y)})`
                 : '(unknown)';

package/dist/esm/lib/page/extendPage.js

@@ -166,7 +166,7 @@ async function extendPage(page, options) {
             aiInvocations: [],
         };
         const showMouse = async (p) => {
-            if (interactionVisualizer.defaultMessageDurationMillis > 0) {
+            if (interactionVisualizer.defaultCursorDurationMillis > 0) {
                 await interactionVisualizer.showMouse(p);
             }
         };

package/dist/esm/lib/test/testExtension.js

@@ -122,28 +122,44 @@ async function waitForPendingVideoPersists(timeoutMs) {
  *   - `'on'`                       → always retain → always persist.
  *   - `'retain-on-failure'`        → retain only on non-passing → persist
  *                                    only when status !== 'passed'.
+ *   - `'retain-on-first-failure'`  → recorded only on the first run; a video
+ *                                    only exists when that run failed → same
+ *                                    persist condition as 'retain-on-failure'.
+ *   - `'retain-on-failure-and-retries'` → retain on non-passing OR on any
+ *                                    retry → persist when status !== 'passed'
+ *                                    or retry > 0.
  *   - `'on-first-retry'`           → recorded only on retries; if a video
  *                                    exists, we're on a retry → persist.
+ *   - `'on-all-retries'`           → recorded on every retry; same as
+ *                                    'on-first-retry' once a video exists.
  *   - any unknown future mode      → conservatively SKIP, with a warn log.
  *                                    Better to under-persist than violate
  *                                    user intent for a mode we don't yet
  *                                    understand.
  */
-function shouldPersistVideo(videoOption, status) {
+function shouldPersistVideo(videoOption, status, retry) {
     const mode = typeof videoOption === 'string' ? videoOption : videoOption?.mode;
     switch (mode) {
         case 'on':
             return true;
         case 'on-first-retry':
-            // When set, Playwright only records on retries; if a video exists
-            // it implies we're on a retry — always retain.
+        case 'on-all-retries':
+            // Playwright only records on retries under these modes; if a video
+            // exists it implies we're on a retry — always retain.
             return true;
         case 'retry-with-video':
             // Deprecated alias for 'on-first-retry' that Playwright still
             // accepts on the type. Same retain semantics.
             return true;
         case 'retain-on-failure':
+        case 'retain-on-first-failure':
+            // Both record up front and discard on a passing run. ('first-failure'
+            // only records the first run, but a video existing already implies
+            // that's the run we're persisting.)
             return status !== 'passed';
+        case 'retain-on-failure-and-retries':
+            // Records every run; kept on failure OR on any retry attempt.
+            return status !== 'passed' || retry > 0;
         case 'off':
         case undefined:
             return false;
@@ -182,7 +198,7 @@ function persistVideoIfApplicable(page, testInfo, videoOption) {
         // and this isn't a retry, etc. Nothing to do.
         return;
     }
-    if (!shouldPersistVideo(videoOption, testInfo.status)) {
+    if (!shouldPersistVideo(videoOption, testInfo.status, testInfo.retry)) {
         Logger_1.appLogger.info(`Skipping video persist for flow ${flowId}: video mode ` +
             `"${describeVideoMode(videoOption)}" + status "${testInfo.status}" ` +
             `means Playwright will discard the file and we'd be violating user ` +

package/dist/esm/managers/DonobuFlowsManager.js

@@ -174,7 +174,7 @@ class DonobuFlowsManager {
                     gptConfigName: gptClientData.gptConfigName,
                     hasGptConfigNameOverride: !gptClientData.agentName,
                     customTools: flowParams.customTools ?? null,
-                    defaultMessageDuration: interactionVisualizer.defaultMessageDurationMillis,
+                    defaultMessageDuration: interactionVisualizer.defaultCursorDurationMillis,
                     callbackUrl: flowParams.callbackUrl || null,
                     overallObjective: flowParams.overallObjective ?? null,
                     allowedTools: allowedTools.map((tool) => tool.name),

package/dist/esm/managers/InteractionVisualizer.d.ts

@@ -1,60 +1,64 @@
 import type { Locator, Page } from 'playwright';
 export declare class InteractionVisualizer {
-    readonly defaultMessageDurationMillis: number;
+    readonly defaultCursorDurationMillis: number;
     private static readonly RAW_MOUSE_D;
     private static readonly TIP_X;
     private static readonly TIP_Y;
     private static readonly SVG_MOUSE;
-    private static readonly SVG_MOUSE_JSON;
-    private static readonly CSS;
-    private static readonly CONTAINER_ID;
-    private cursorPos;
-    constructor(defaultMessageDurationMillis: number);
     /**
-     * Moves the virtual cursor to the center of the specified element and optionally displays a message.
+     * Upper bound on resolving a target's bounding box. `Locator.boundingBox`
+     * defaults to *no* timeout, so a locator that resolves to zero elements
+     * (e.g. detached mid-flow) would otherwise wait forever and hang the flow.
+     * The cursor is cosmetic, so we cap the wait and treat a miss as a no-op.
+     */
+    private static readonly BOUNDING_BOX_TIMEOUT_MILLIS;
+    /**
+     * Per-page cursor state. Keyed weakly so closed/GC'd pages drop out without
+     * us tracking page lifecycles.
+     */
+    private readonly states;
+    constructor(defaultCursorDurationMillis: number);
+    /**
+     * Moves the virtual cursor to the center of the specified element.
      *
      * @param page - The Playwright page instance where the cursor will be displayed.
      * @param locator - Optional target element to point at. If omitted, cursor remains at current position.
-     * @param message - Optional message to display near the cursor during the interaction.
-     * @param duration - Duration in milliseconds for the cursor animation and message display.
+     * @param duration - Duration in milliseconds for the cursor animation.
      *                   Defaults to the instance's configured duration. If ≤ 0, no action is taken
      *
-     * @returns Promise that resolves when the cursor movement and message display are complete
+     * @returns Promise that resolves once the cursor has reached the target
      *
      * @remarks
-     * - The target element will be scrolled into view if necessary
      * - The cursor animates smoothly to the element's center point
-     * - Messages are positioned automatically to avoid viewport edges
-     * - The virtual cursor does not interfere with actual page interactions
+     * - The overlay is `pointer-events: none`, so it never intercepts real interactions
      */
-    pointAt(page: Page, locator?: Pick<Locator, 'boundingBox'>, message?: string, duration?: number): Promise<void>;
+    pointAt(page: Page, locator?: Pick<Locator, 'boundingBox'>, duration?: number): Promise<void>;
     /**
-     * Shows the virtual mouse cursor on the page.
+     * Shows the virtual mouse cursor on the page at its current position.
      *
      * @param page - The Playwright page instance where the cursor will be displayed.
-     *
      * @returns Promise that resolves when the cursor is shown.
-     *
-     * @remarks
-     * - If the cursor doesn't exist yet, it will be created.
-     * - The cursor will be made visible with a smooth opacity transition.
      */
     showMouse(page: Page): Promise<void>;
     /**
      * Hides the virtual mouse cursor on the page.
      *
      * @param page - The Playwright page instance where the cursor is displayed.
-     *
-     * @returns Promise that resolves when the cursor is hidden
-     *
-     * @remarks
-     * - The cursor will be hidden with a smooth opacity transition
-     * - The cursor element remains in the DOM but becomes invisible
+     * @returns Promise that resolves when the cursor is hidden.
      */
     hideMouse(page: Page): Promise<void>;
-    private ensureContainer;
-    private ensureCursor;
-    private moveCursor;
-    private showMessage;
+    private getState;
+    /**
+     * Replaces the sticky cursor overlay with one positioned at `to`, gliding
+     * from `from` when `animMs > 0`. We show the new overlay before disposing
+     * the old one to avoid a visible flicker, and tolerate a stale disposable
+     * (e.g. cleared by a navigation) by swallowing its dispose error.
+     */
+    private renderCursor;
+    /**
+     * Builds the cursor overlay markup: the arrow SVG plus a `@keyframes` glide
+     * from the previous position and a one-shot ripple at the arrow tip.
+     */
+    private buildCursorHtml;
 }
 //# sourceMappingURL=InteractionVisualizer.d.ts.map

package/dist/esm/managers/InteractionVisualizer.js

@@ -4,49 +4,55 @@ exports.InteractionVisualizer = void 0;
 const Logger_1 = require("../utils/Logger");
 const PlaywrightUtils_1 = require("../utils/PlaywrightUtils");
 class InteractionVisualizer {
-    constructor(defaultMessageDurationMillis) {
-        this.defaultMessageDurationMillis = defaultMessageDurationMillis;
-        this.cursorPos = { x: 150, y: 150 };
+    constructor(defaultCursorDurationMillis) {
+        this.defaultCursorDurationMillis = defaultCursorDurationMillis;
+        /**
+         * Per-page cursor state. Keyed weakly so closed/GC'd pages drop out without
+         * us tracking page lifecycles.
+         */
+        this.states = new WeakMap();
     }
     /* ------------------------------------------------------------------ */
     /*  Public API                                                        */
     /* ------------------------------------------------------------------ */
     /**
-     * Moves the virtual cursor to the center of the specified element and optionally displays a message.
+     * Moves the virtual cursor to the center of the specified element.
      *
      * @param page - The Playwright page instance where the cursor will be displayed.
      * @param locator - Optional target element to point at. If omitted, cursor remains at current position.
-     * @param message - Optional message to display near the cursor during the interaction.
-     * @param duration - Duration in milliseconds for the cursor animation and message display.
+     * @param duration - Duration in milliseconds for the cursor animation.
      *                   Defaults to the instance's configured duration. If ≤ 0, no action is taken
      *
-     * @returns Promise that resolves when the cursor movement and message display are complete
+     * @returns Promise that resolves once the cursor has reached the target
      *
      * @remarks
-     * - The target element will be scrolled into view if necessary
      * - The cursor animates smoothly to the element's center point
-     * - Messages are positioned automatically to avoid viewport edges
-     * - The virtual cursor does not interfere with actual page interactions
+     * - The overlay is `pointer-events: none`, so it never intercepts real interactions
      */
-    async pointAt(page, locator, message, duration = this.defaultMessageDurationMillis) {
+    async pointAt(page, locator, duration = this.defaultCursorDurationMillis) {
         if (!duration || duration <= 0) {
             return;
         }
         try {
-            let target = { x: this.cursorPos.x, y: this.cursorPos.y };
+            const state = this.getState(page);
+            const from = { ...state.pos };
+            let target = from;
             if (locator) {
-                const box = await locator.boundingBox();
+                // Cap the wait and swallow a timeout: an unresolvable locator must
+                // leave the (cosmetic) cursor in place, never block the flow.
+                const box = await locator
+                    .boundingBox({
+                    timeout: InteractionVisualizer.BOUNDING_BOX_TIMEOUT_MILLIS,
+                })
+                    .catch(() => null);
                 if (box) {
                     target = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
                 }
             }
-            await this.ensureContainer(page);
-            await Promise.all([
-                this.moveCursor(page, target, duration / 2),
-                message?.trim()
-                    ? this.showMessage(page, target, message.trim(), duration)
-                    : Promise.resolve(),
-            ]);
+            state.pos = target;
+            if (state.visible) {
+                await this.renderCursor(page, state, from, target, duration / 2);
+            }
         }
         catch (error) {
             if (!PlaywrightUtils_1.PlaywrightUtils.isPageClosedError(error)) {
@@ -55,28 +61,16 @@ class InteractionVisualizer {
         }
     }
     /**
-     * Shows the virtual mouse cursor on the page.
+     * Shows the virtual mouse cursor on the page at its current position.
      *
      * @param page - The Playwright page instance where the cursor will be displayed.
-     *
      * @returns Promise that resolves when the cursor is shown.
-     *
-     * @remarks
-     * - If the cursor doesn't exist yet, it will be created.
-     * - The cursor will be made visible with a smooth opacity transition.
      */
     async showMouse(page) {
         try {
-            await this.ensureContainer(page);
-            await this.ensureCursor(page);
-            await page.evaluate(([containerId]) => {
-                const root = document.getElementById(containerId)
-                    .shadowRoot;
-                const cursor = root.querySelector('.donobu-virtual-mouse');
-                if (cursor) {
-                    cursor.classList.remove('hidden');
-                }
-            }, [InteractionVisualizer.CONTAINER_ID]);
+            const state = this.getState(page);
+            state.visible = true;
+            await this.renderCursor(page, state, state.pos, state.pos, 0);
         }
         catch (error) {
             if (!PlaywrightUtils_1.PlaywrightUtils.isPageClosedError(error)) {
@@ -84,30 +78,22 @@ class InteractionVisualizer {
             }
         }
     }
+    /* ------------------------------------------------------------------ */
+    /*  Private helpers                                                   */
+    /* ------------------------------------------------------------------ */
     /**
      * Hides the virtual mouse cursor on the page.
      *
      * @param page - The Playwright page instance where the cursor is displayed.
-     *
-     * @returns Promise that resolves when the cursor is hidden
-     *
-     * @remarks
-     * - The cursor will be hidden with a smooth opacity transition
-     * - The cursor element remains in the DOM but becomes invisible
+     * @returns Promise that resolves when the cursor is hidden.
      */
     async hideMouse(page) {
         try {
-            const id = InteractionVisualizer.CONTAINER_ID;
-            await page.evaluate(([containerId]) => {
-                const container = document.getElementById(containerId);
-                if (!container?.shadowRoot) {
-                    return;
-                }
-                const cursor = container.shadowRoot.querySelector('.donobu-virtual-mouse');
-                if (cursor) {
-                    cursor.classList.add('hidden');
-                }
-            }, [id]);
+            const state = this.getState(page);
+            state.visible = false;
+            const cursor = state.cursor;
+            state.cursor = undefined;
+            await cursor?.dispose();
         }
         catch (error) {
             if (!PlaywrightUtils_1.PlaywrightUtils.isPageClosedError(error)) {
@@ -115,138 +101,64 @@ class InteractionVisualizer {
             }
         }
     }
-    /* ------------------------------------------------------------------ */
-    /*  Private helpers                                                   */
-    /* ------------------------------------------------------------------ */
-    async ensureContainer(page) {
-        const id = InteractionVisualizer.CONTAINER_ID;
-        await page.evaluate(([containerId, css]) => {
-            if (document.getElementById(containerId)) {
-                return;
-            }
-            const el = document.createElement('div');
-            el.id = containerId;
-            Object.assign(el.style, {
-                position: 'fixed',
-                top: '0',
-                left: '0',
-                width: '100vw',
-                height: '100vh',
-                pointerEvents: 'none',
-                zIndex: '2147483646', // just below the message itself
-            });
-            const shadow = el.attachShadow({ mode: 'open' });
-            const style = document.createElement('style');
-            style.textContent = css;
-            shadow.appendChild(style);
-            // Append to <html> so it is not clipped by overflow/transform on <body>
-            (document.documentElement || document.body).appendChild(el);
-        }, [id, InteractionVisualizer.CSS]);
+    getState(page) {
+        let state = this.states.get(page);
+        if (!state) {
+            state = { pos: { x: 150, y: 150 }, visible: false };
+            this.states.set(page, state);
+        }
+        return state;
     }
-    async ensureCursor(page) {
-        const id = InteractionVisualizer.CONTAINER_ID;
-        await page.evaluate(([containerId, position, svg, svgAttrs, tipX, tipY]) => {
-            const root = document.getElementById(containerId).shadowRoot;
-            let cursor = root.querySelector('.donobu-virtual-mouse');
-            if (cursor) {
-                return;
-            }
-            cursor = document.createElement('div');
-            cursor.className = 'donobu-virtual-mouse hidden';
-            // Hybrid approach: try insertAdjacentHTML first, fallback to createElementNS
+    /**
+     * Replaces the sticky cursor overlay with one positioned at `to`, gliding
+     * from `from` when `animMs > 0`. We show the new overlay before disposing
+     * the old one to avoid a visible flicker, and tolerate a stale disposable
+     * (e.g. cleared by a navigation) by swallowing its dispose error.
+     */
+    async renderCursor(page, state, from, to, animMs) {
+        const previous = state.cursor;
+        state.cursor = await page.screencast.showOverlay(this.buildCursorHtml(from, to, animMs));
+        if (previous) {
             try {
-                cursor.insertAdjacentHTML('beforeend', svg);
+                await previous.dispose();
             }
-            catch (_error) {
-                // Fallback: create SVG programmatically using attributes object
-                const attrs = JSON.parse(svgAttrs);
-                const svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
-                // Set SVG attributes
-                Object.entries(attrs.svg).forEach(([key, value]) => {
-                    svgElement.setAttribute(key, value);
-                });
-                // Create and add path element
-                const path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
-                Object.entries(attrs.path).forEach(([key, value]) => {
-                    path.setAttribute(key, value);
-                });
-                svgElement.appendChild(path);
-                cursor.appendChild(svgElement);
+            catch {
+                // Stale overlay (page navigated/closed) — the fresh one already replaced it.
             }
-            const pos = position;
-            cursor.style.transitionDuration = '0s';
-            cursor.style.transform = `translate(${pos.x - tipX}px, ${pos.y - tipY}px)`;
-            root.appendChild(cursor);
-        }, [
-            id,
-            this.cursorPos,
-            InteractionVisualizer.SVG_MOUSE,
-            JSON.stringify(InteractionVisualizer.SVG_MOUSE_JSON),
-            InteractionVisualizer.TIP_X,
-            InteractionVisualizer.TIP_Y,
-        ]);
-    }
-    async moveCursor(page, target, duration) {
-        await this.ensureCursor(page);
-        const id = InteractionVisualizer.CONTAINER_ID;
-        await page.evaluate(([containerId, end, duration, tipX, tipY]) => {
-            const root = document.getElementById(containerId).shadowRoot;
-            const cursor = root.querySelector('.donobu-virtual-mouse');
-            cursor.style.transitionDuration = `${duration}ms`;
-            const endPos = end;
-            cursor.style.transform = `translate(${endPos.x - tipX}px, ${endPos.y - tipY}px)`;
-            cursor.classList.add('rippling');
-            const done = new Promise((resolve) => {
-                const finish = () => {
-                    cursor.removeEventListener('transitionend', finish);
-                    cursor.classList.remove('rippling');
-                    resolve();
-                };
-                cursor.addEventListener('transitionend', finish);
-                setTimeout(finish, duration + 50);
+        }
+        // showOverlay resolves the moment the overlay is added, before the CSS
+        // glide plays. Callers (e.g. ClickTool) await pointAt expecting the cursor
+        // to reach the element *before* they act, so block for the animation here.
+        // Only the moving case animates (see buildCursorHtml), so a no-op move
+        // (e.g. an unresolved target) shouldn't incur the wait.
+        const animating = animMs > 0 && (from.x !== to.x || from.y !== to.y);
+        if (animating) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, animMs);
             });
-            return done;
-        }, [
-            id,
-            target,
-            duration,
-            InteractionVisualizer.TIP_X,
-            InteractionVisualizer.TIP_Y,
-        ]);
-        this.cursorPos = target;
+        }
     }
-    async showMessage(page, target, text, duration) {
-        const id = InteractionVisualizer.CONTAINER_ID;
-        await page.evaluate(([containerId, target, text, duration]) => {
-            containerId = containerId;
-            target = target;
-            text = text;
-            duration = duration;
-            const root = document.getElementById(containerId)
-                .shadowRoot;
-            const msg = document.createElement('div');
-            msg.className = 'donobu-message';
-            msg.textContent = text;
-            root.appendChild(msg);
-            /* ── compute final coordinates ────────────────────────────────── */
-            const { width, height } = msg.getBoundingClientRect();
-            let x = target.x - width / 2;
-            let y = target.y + 24; // default - below cursor
-            /* clamp horizontally inside viewport */
-            x = Math.max(8, Math.min(window.innerWidth - width - 8, x));
-            /* if it overflows bottom, flip above the element */
-            if (y + height + 8 > window.innerHeight) {
-                y = target.y - height - 24;
-            }
-            /* if still off-screen at the top, clamp to 8 px margin */
-            if (y < 8) {
-                y = 8;
-            }
-            msg.style.left = `${x}px`;
-            msg.style.top = `${y}px`;
-            /* auto-remove after the requested duration */
-            setTimeout(() => msg.remove(), duration);
-        }, [id, target, text, duration]);
+    /**
+     * Builds the cursor overlay markup: the arrow SVG plus a `@keyframes` glide
+     * from the previous position and a one-shot ripple at the arrow tip.
+     */
+    buildCursorHtml(from, to, animMs) {
+        const tipX = InteractionVisualizer.TIP_X;
+        const tipY = InteractionVisualizer.TIP_Y;
+        const fx = from.x - tipX;
+        const fy = from.y - tipY;
+        const tx = to.x - tipX;
+        const ty = to.y - tipY;
+        const animate = animMs > 0 && (from.x !== to.x || from.y !== to.y);
+        return `
+<style>
+  @keyframes donobu-glide { from { transform: translate(${fx}px, ${fy}px); } to { transform: translate(${tx}px, ${ty}px); } }
+  @keyframes donobu-ripple { 0% { transform: translate(-50%,-50%) scale(.5); opacity:0; } 40% { transform: translate(-50%,-50%) scale(1); opacity:.5; } 100% { transform: translate(-50%,-50%) scale(2); opacity:0; } }
+  .donobu-cursor { position:fixed; left:0; top:0; width:32px; height:32px; z-index:2147483646; pointer-events:none; filter:drop-shadow(1px 1px 1px rgba(0,0,0,.5)); transform: translate(${tx}px, ${ty}px); ${animate ? `animation: donobu-glide ${animMs}ms ease-in-out;` : ''} }
+  .donobu-cursor svg { width:100%; height:100%; display:block; }
+  ${animate ? `.donobu-cursor::after { content:""; position:absolute; left:${tipX}px; top:${tipY}px; width:24px; height:24px; border-radius:50%; background:#FF781B; opacity:0; animation: donobu-ripple .6s ease-out ${animMs}ms both; }` : ''}
+</style>
+<div class="donobu-cursor">${InteractionVisualizer.SVG_MOUSE}</div>`;
     }
 }
 exports.InteractionVisualizer = InteractionVisualizer;
@@ -269,29 +181,11 @@ InteractionVisualizer.SVG_MOUSE = `
      stroke-linejoin="round">
   <path d="${InteractionVisualizer.RAW_MOUSE_D}" />
 </svg>`;
-InteractionVisualizer.SVG_MOUSE_JSON = {
-    svg: {
-        xmlns: 'http://www.w3.org/2000/svg',
-        width: '32',
-        height: '32',
-        viewBox: '0 0 24 24',
-        fill: 'oklch(13.09% 0.005 165.18)',
-        stroke: '#FF781B',
-        'stroke-width': '2',
-        'stroke-linecap': 'round',
-        'stroke-linejoin': 'round',
-    },
-    path: {
-        d: InteractionVisualizer.RAW_MOUSE_D,
-    },
-};
-InteractionVisualizer.CSS = `
-  .donobu-message{position:absolute;z-index:2147483647;background:#000;color:#fff;padding:8px 10px;border-radius:5px;font:12px/1 'Source Sans Pro','Helvetica Neue',Helvetica,Arial,sans-serif;max-width:300px;white-space:pre-wrap;box-shadow:2px 2px 10px rgba(0,0,0,.2);pointer-events:none}
-  .donobu-virtual-mouse{width:24px;height:24px;position:absolute;z-index:2147483646;filter:drop-shadow(1px 1px 1px rgba(0,0,0,.5));transition:transform .15s ease-in-out;pointer-events:none;opacity:1;visibility:visible}
-  .donobu-virtual-mouse.hidden{opacity:0;visibility:hidden}
-  .donobu-virtual-mouse svg{width:100%;height:100%;display:block}
-  .donobu-virtual-mouse.rippling::after{content:"";position:absolute;left:${InteractionVisualizer.TIP_X}px;top:${InteractionVisualizer.TIP_Y}px;width:24px;height:24px;border-radius:50%;background:#FF781B;transform:translate(-50%,-50%) scale(.5);opacity:.4;animation:ripple-pop .6s ease-out forwards}
-  @keyframes ripple-pop{40%{transform:translate(-50%,-50%) scale(1);opacity:.5}100%{transform:translate(-50%,-50%) scale(2);opacity:0}}
-`;
-InteractionVisualizer.CONTAINER_ID = 'donobu-iv-overlay';
+/**
+ * Upper bound on resolving a target's bounding box. `Locator.boundingBox`
+ * defaults to *no* timeout, so a locator that resolves to zero elements
+ * (e.g. detached mid-flow) would otherwise wait forever and hang the flow.
+ * The cursor is cosmetic, so we cap the wait and treat a miss as a no-op.
+ */
+InteractionVisualizer.BOUNDING_BOX_TIMEOUT_MILLIS = 1000;
 //# sourceMappingURL=InteractionVisualizer.js.map

package/dist/esm/tools/ReplayableInteraction.js

@@ -432,7 +432,7 @@ class ReplayableInteraction extends Tool_1.Tool {
         // Only reveal the cursor now that we have a real target to point at, so a
         // non-interactive proposal never pops a stationary cursor.
         await (0, TargetUtils_1.webInspector)(context).showInteractionCursor();
-        await context.interactionVisualizer.pointAt(page, pointTarget.first(), undefined, ReplayableInteraction.PREVIEW_CURSOR_DURATION_MILLIS);
+        await context.interactionVisualizer.pointAt(page, pointTarget.first(), ReplayableInteraction.PREVIEW_CURSOR_DURATION_MILLIS);
     }
     async callFromGpt(context, parameters) {
         const page = (0, TargetUtils_1.webPage)(context);

package/dist/esm/utils/BrowserUtils.js

@@ -199,22 +199,7 @@ class BrowserUtils {
                     // If the entry exists but doesn't have sessionStorage yet, add the property
                     originEntry.sessionStorage = [];
                 }
-                // Extract sessionStorage from the page
-                const sessionStorageItems = await page.evaluate(() => {
-                    const items = [];
-                    for (let i = 0; i < sessionStorage.length; i++) {
-                        const name = sessionStorage.key(i);
-                        if (name) {
-                            items.push({
-                                name,
-                                value: sessionStorage.getItem(name) || '',
-                            });
-                        }
-                    }
-                    return items;
-                });
-                // Add sessionStorage items to the origin entry
-                originEntry.sessionStorage = sessionStorageItems;
+                originEntry.sessionStorage = await page.sessionStorage.items();
             }
             catch (error) {
                 Logger_1.appLogger.warn(`Failed to extract sessionStorage for page: ${pageUrl}`, error);

package/dist/lib/ai/locate/locateElement.js

@@ -13,6 +13,14 @@ const locateSchema_1 = require("./locateSchema");
 const DISAMBIGUATE_THRESHOLD = 5;
 /** Maximum outer HTML length per snippet shown during disambiguation. */
 const SNIPPET_MAX_CHARS = 200;
+/**
+ * Per-candidate read budget during disambiguation. Locator `evaluate`/
+ * `boundingBox` default to *no* timeout, so a candidate that detaches mid-loop
+ * would wait forever (the surrounding try/catch only traps errors, not hangs,
+ * and the AbortSignal isn't plumbed into these ops). Cap it and let a miss fall
+ * through to the placeholder snippet below.
+ */
+const CANDIDATE_READ_TIMEOUT_MILLIS = 1000;
 /**
  * Resolve a natural-language element description to a Playwright {@link Locator}.
  *
@@ -87,8 +95,10 @@ async function disambiguate(page, description, gptClient, locator, locateResult,
             const html = await nth.evaluate((el, max) => {
                 const raw = el.outerHTML;
                 return raw.length > max ? raw.slice(0, max) + '…' : raw;
-            }, SNIPPET_MAX_CHARS);
-            const box = await nth.boundingBox();
+            }, SNIPPET_MAX_CHARS, { timeout: CANDIDATE_READ_TIMEOUT_MILLIS });
+            const box = await nth.boundingBox({
+                timeout: CANDIDATE_READ_TIMEOUT_MILLIS,
+            });
             const pos = box
                 ? `(${Math.round(box.x)}, ${Math.round(box.y)})`
                 : '(unknown)';