cdp-skill 1.0.15 → 1.0.17

package/{src → scripts}/dom/actionability.js

@@ -22,9 +22,22 @@ const stableFrameCount = 3;
 /**
  * Create an actionability checker for Playwright-style auto-waiting
  * @param {Object} session - CDP session
+ * @param {Object} [options] - Options
+ * @param {function(): number|null} [options.getFrameContext] - Returns contextId for current frame
  * @returns {Object} Actionability checker interface
  */
-export function createActionabilityChecker(session) {
+export function createActionabilityChecker(session, options = {}) {
+  const { getFrameContext } = options;
+
+  /** Build Runtime.evaluate params with frame context when in an iframe. */
+  function evalParams(expression, returnByValue = true) {
+    const params = { expression, returnByValue };
+    if (getFrameContext) {
+      const contextId = getFrameContext();
+      if (contextId) params.contextId = contextId;
+    }
+    return params;
+  }
   // Simplified: removed stability check, shorter retry delays
   const retryDelays = [0, 50, 100, 200];
 
@@ -48,10 +61,18 @@ export function createActionabilityChecker(session) {
 
   async function findElementInternal(selector) {
     try {
-      const result = await session.send('Runtime.evaluate', {
-        expression: `document.querySelector(${JSON.stringify(selector)})`,
-        returnByValue: false
-      });
+      const result = await session.send('Runtime.evaluate',
+        evalParams(`document.querySelector(${JSON.stringify(selector)})`, false)
+      );
+
+      // Check for selector syntax errors (e.g., invalid CSS selectors)
+      if (result.exceptionDetails) {
+        const msg = result.exceptionDetails.exception?.description ||
+                    result.exceptionDetails.exception?.value ||
+                    result.exceptionDetails.text ||
+                    'Unknown selector error';
+        return { success: false, error: `Selector error: ${msg}`, immediate: true };
+      }
 
       if (result.result.subtype === 'null' || !result.result.objectId) {
         return { success: false, error: `Element not found: ${selector}` };
@@ -302,6 +323,10 @@ export function createActionabilityChecker(session) {
       const element = await findElementInternal(selector);
       if (!element.success) {
         lastError = element.error;
+        // Immediate failures (syntax errors) should not retry
+        if (element.immediate) {
+          return { success: false, error: element.error };
+        }
         retry++;
         continue;
       }
@@ -456,14 +481,9 @@ export function createActionabilityChecker(session) {
       // Check if the hit element is a child of our target (also valid)
       const isChild = await session.send('Runtime.callFunctionOn', {
         objectId,
-        functionDeclaration: `function(hitNodeId) {
-          // We need to find if the hit element is inside this element
-          // This is tricky because we only have backend node IDs
-          // Use elementFromPoint as a fallback check
-          const rect = this.getBoundingClientRect();
-          const centerX = rect.left + rect.width / 2;
-          const centerY = rect.top + rect.height / 2;
-          const hitEl = document.elementFromPoint(centerX, centerY);
+        functionDeclaration: `function(pt) {
+          // Use the provided point coordinates for elementFromPoint check
+          const hitEl = document.elementFromPoint(pt.x, pt.y);
 
           if (!hitEl) return { isChild: false, coverInfo: 'no-element' };
 
@@ -481,6 +501,7 @@ export function createActionabilityChecker(session) {
 
           return { isChild: false, coverInfo: desc };
         }`,
+        arguments: [{ value: point }],
         returnByValue: true
       });
 
@@ -499,19 +520,17 @@ export function createActionabilityChecker(session) {
       try {
         const fallbackResult = await session.send('Runtime.callFunctionOn', {
           objectId,
-          functionDeclaration: `function() {
-            const rect = this.getBoundingClientRect();
-            const centerX = rect.left + rect.width / 2;
-            const centerY = rect.top + rect.height / 2;
-            const hitEl = document.elementFromPoint(centerX, centerY);
+          functionDeclaration: `function(pt) {
+            const hitEl = document.elementFromPoint(pt.x, pt.y);
 
-            if (!hitEl) return { covered: true, coverInfo: 'no-element-at-center' };
+            if (!hitEl) return { covered: true, coverInfo: 'no-element-at-point' };
             if (hitEl === this || this.contains(hitEl)) return { covered: false };
 
             let desc = hitEl.tagName.toLowerCase();
             if (hitEl.id) desc += '#' + hitEl.id;
             return { covered: true, coverInfo: desc };
           }`,
+          arguments: [{ value: point }],
           returnByValue: true
         });
         return {
@@ -592,9 +611,7 @@ export function createActionabilityChecker(session) {
 
       // Scroll the page
       const scrollDir = direction === 'up' ? -scrollAmount : scrollAmount;
-      await session.send('Runtime.evaluate', {
-        expression: `window.scrollBy(0, ${scrollDir})`
-      });
+      await session.send('Runtime.evaluate', evalParams(`window.scrollBy(0, ${scrollDir})`));
 
       scrollCount++;
       await sleep(200); // Wait for content to load/render

package/{src → scripts}/dom/click-executor.js

@@ -8,12 +8,10 @@
  *
  * DEPENDENCIES:
  * - ./actionability.js: createActionabilityChecker
- * - ./element-validator.js: createElementValidator
  * - ../utils.js: sleep, elementNotFoundError, getCurrentUrl, getElementAtPoint, detectNavigation, releaseObject
  */
 
 import { createActionabilityChecker } from './actionability.js';
-import { createElementValidator } from './element-validator.js';
 import { createLazyResolver } from './LazyResolver.js';
 import {
   sleep,
@@ -39,8 +37,7 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
   if (!inputEmulator) throw new Error('Input emulator is required');
 
   const getFrameContext = elementLocator.getFrameContext || null;
-  const actionabilityChecker = createActionabilityChecker(session);
-  const elementValidator = createElementValidator(session);
+  const actionabilityChecker = createActionabilityChecker(session, { getFrameContext });
   const lazyResolver = createLazyResolver(session, { getFrameContext });
 
   /** Build Runtime.evaluate params with frame context when in an iframe. */
@@ -61,8 +58,8 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
       visibleBox.y = Math.max(box.y, 0);
       const right = Math.min(box.x + box.width, viewport.width);
       const bottom = Math.min(box.y + box.height, viewport.height);
-      visibleBox.width = right - visibleBox.x;
-      visibleBox.height = bottom - visibleBox.y;
+      visibleBox.width = Math.max(0, right - visibleBox.x);
+      visibleBox.height = Math.max(0, bottom - visibleBox.y);
     }
 
     return {
@@ -402,16 +399,25 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
           if (matchesRoleAndName(el)) return el;
         }
 
-        // Strategy 3: Search in shadow roots
-        const shadowHosts = document.querySelectorAll('*');
-        for (const host of shadowHosts) {
-          if (host.shadowRoot) {
-            const els = host.shadowRoot.querySelectorAll(selectorString);
+        // Strategy 3: Search in shadow roots via tree walk (avoids querySelectorAll('*'))
+        function searchShadowRoots(node) {
+          if (node.shadowRoot) {
+            const els = node.shadowRoot.querySelectorAll(selectorString);
             for (const el of els) {
               if (matchesRoleAndName(el)) return el;
             }
+            const found = searchShadowRoots(node.shadowRoot);
+            if (found) return found;
           }
+          const children = node.children || [];
+          for (const child of children) {
+            const found = searchShadowRoots(child);
+            if (found) return found;
+          }
+          return null;
         }
+        const shadowResult = searchShadowRoots(document.body);
+        if (shadowResult) return shadowResult;
       }
 
       return null;
@@ -562,7 +568,7 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
   }
 
   async function clickAtCoordinates(x, y, opts = {}) {
-    const { debug = false, waitForNavigation = false, navigationTimeout = 100 } = opts;
+    const { debug = false, waitForNavigation = false, navigationTimeout = 100, waitAfter = false, waitAfterOptions = {} } = opts;
 
     const urlBeforeClick = await getCurrentUrl(session);
 
@@ -579,38 +585,27 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
       coordinates: { x, y }
     };
 
-    if (waitForNavigation) {
-      const navResult = await detectNavigation(session, urlBeforeClick, navigationTimeout);
-      result.navigated = navResult.navigated;
-      if (navResult.newUrl) {
-        result.newUrl = navResult.newUrl;
-      }
-    }
-
-    if (debug) {
-      result.debug = {
-        clickedAt: { x, y },
-        elementHit: elementAtPoint
-      };
-    }
-
-    return result;
+    return addNavigationAndDebugInfo(result, urlBeforeClick, { point: { x, y }, elementAtPoint }, { waitForNavigation, navigationTimeout, debug, waitAfter, waitAfterOptions });
   }
 
+  let clickVerifyCounter = 0;
+
   async function clickWithVerificationByRef(ref, x, y) {
     // Use pointerdown for verification instead of click.
     // React re-renders between mousedown and click, destroying the original DOM node.
     // pointerdown fires synchronously before any re-render.
     // Also uses document-level capture as fallback for descendant hits.
     // LAZY RESOLUTION: Always resolve ref from metadata, never rely on cached element.
+    const verifyKey = `__clickVerify_${++clickVerifyCounter}`;
+
     await session.send('Runtime.evaluate', frameEvalParams(`
         (function() {
           ${LAZY_RESOLVE_SCRIPT}
 
           const el = lazyResolveRef(${JSON.stringify(ref)});
           if (el && el.isConnected) {
-            // Store resolved element for verification phase
-            window.__clickVerifyEl = el;
+            // Store resolved element for verification phase (unique key per click)
+            window[${JSON.stringify(verifyKey)}] = el;
             el.__clickReceived = false;
             el.__ptrHandler = () => { el.__clickReceived = true; };
             el.addEventListener('pointerdown', el.__ptrHandler, { once: true });
@@ -624,16 +619,35 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
         })()
       `, false));
 
-    await inputEmulator.click(x, y);
-    await sleep(50);
+    try {
+      await inputEmulator.click(x, y);
+      await sleep(50);
+    } catch (clickError) {
+      // Cleanup listeners on click failure
+      try {
+        await session.send('Runtime.evaluate', frameEvalParams(`
+            (function() {
+              const el = window[${JSON.stringify(verifyKey)}];
+              delete window[${JSON.stringify(verifyKey)}];
+              if (!el) return;
+              if (el.__ptrHandler) el.removeEventListener('pointerdown', el.__ptrHandler);
+              if (el.__docHandler) document.removeEventListener('pointerdown', el.__docHandler, { capture: true });
+              delete el.__clickReceived;
+              delete el.__ptrHandler;
+              delete el.__docHandler;
+            })()
+          `, true));
+      } catch { /* ignore cleanup errors */ }
+      throw clickError;
+    }
 
     // Check if pointerdown was received
     let verifyResult;
     try {
       verifyResult = await session.send('Runtime.evaluate', frameEvalParams(`
           (function() {
-            const el = window.__clickVerifyEl;
-            delete window.__clickVerifyEl;
+            const el = window[${JSON.stringify(verifyKey)}];
+            delete window[${JSON.stringify(verifyKey)}];
             if (!el) return { targetReceived: false, reason: 'element not found' };
             if (el.__ptrHandler) el.removeEventListener('pointerdown', el.__ptrHandler);
             if (el.__docHandler) document.removeEventListener('pointerdown', el.__docHandler, { capture: true });
@@ -657,7 +671,7 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
   }
 
   async function clickByRef(ref, jsClick = false, opts = {}) {
-    const { force = false, debug = false, nativeOnly = false, waitForNavigation, navigationTimeout = 100 } = opts;
+    const { force = false, debug = false, nativeOnly = false, waitForNavigation, navigationTimeout = 100, waitAfter = false, waitAfterOptions = {} } = opts;
 
     // LAZY RESOLUTION: Always resolve ref from metadata, never rely on cached element
     // This eliminates stale element errors entirely
@@ -666,19 +680,24 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
       throw elementNotFoundError(`ref:${ref}`, 0);
     }
 
-    // Get visibility info using the resolved element
-    const visibilityResult = await session.send('Runtime.callFunctionOn', {
-      objectId: resolved.objectId,
-      functionDeclaration: `function() {
-        const style = window.getComputedStyle(this);
-        const rect = this.getBoundingClientRect();
-        return {
-          isVisible: style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0' && rect.width > 0 && rect.height > 0,
-          box: { x: rect.x, y: rect.y, width: rect.width, height: rect.height }
-        };
-      }`,
-      returnByValue: true
-    });
+    // Get visibility info using the resolved element, then release the objectId
+    let visibilityResult;
+    try {
+      visibilityResult = await session.send('Runtime.callFunctionOn', {
+        objectId: resolved.objectId,
+        functionDeclaration: `function() {
+          const style = window.getComputedStyle(this);
+          const rect = this.getBoundingClientRect();
+          return {
+            isVisible: style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0' && rect.width > 0 && rect.height > 0,
+            box: { x: rect.x, y: rect.y, width: rect.width, height: rect.height }
+          };
+        }`,
+        returnByValue: true
+      });
+    } finally {
+      await releaseObject(session, resolved.objectId);
+    }
 
     const refInfo = {
       box: visibilityResult.result?.value?.box || resolved.box,
@@ -757,7 +776,8 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
     // If element is outside viewport (e.g., inside an unscrolled container), scroll it into view first
     // LAZY RESOLUTION: Always resolve ref from metadata for scroll
     const box = refInfo.box;
-    if (box && (box.x < 0 || box.y < 0 || box.x + box.width > 1920 || box.y + box.height > 1080)) {
+    const vp = await getViewportBounds().catch(() => null) || { width: 1280, height: 720 };
+    if (box && (box.x < 0 || box.y < 0 || box.x + box.width > vp.width || box.y + box.height > vp.height)) {
       try {
         await session.send('Runtime.evaluate', frameEvalParams(`
           (function() {
@@ -769,8 +789,13 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
         await sleep(100);
         // Re-fetch element info after scroll using lazy resolution
         const updatedResult = await lazyResolver.resolveRef(ref);
-        if (updatedResult && updatedResult.box) {
-          refInfo.box = updatedResult.box;
+        if (updatedResult) {
+          if (updatedResult.box) {
+            refInfo.box = updatedResult.box;
+          }
+          if (updatedResult.objectId) {
+            await releaseObject(session, updatedResult.objectId);
+          }
         }
       } catch {
         // Scroll failed — proceed with original coordinates
@@ -877,6 +902,16 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
       }
     }
 
+    // Auto-wait after click
+    if (waitAfter) {
+      const changeResult = await detectContentChange({
+        timeout: waitAfterOptions.timeout || 5000,
+        stableTime: waitAfterOptions.stableTime || 500,
+        checkNavigation: true
+      });
+      result.waitResult = changeResult;
+    }
+
     if (debug) {
       result.debug = {
         clickedAt: point,
@@ -1194,8 +1229,10 @@ export function createClickExecutor(session, elementLocator, inputEmulator, aria
       if (!scrollResult.found) {
         throw elementNotFoundError(selector, scrollOptions.timeout || 30000);
       }
-      // Element found, now proceed with normal click
-      // The scrollUntilVisible already scrolled it into view, so the actionability check should pass
+      // Release the objectId from scrollUntilVisible — clickBySelector will re-find the element
+      if (scrollResult.objectId) {
+        await releaseObject(session, scrollResult.objectId);
+      }
     }
 
     return clickBySelector(selector, { jsClick, nativeOnly, force, debug, waitForNavigation, navigationTimeout, waitAfter, waitAfterOptions });

package/{src → scripts}/dom/element-locator.js

@@ -205,16 +205,16 @@ export function createElementLocator(session, options = {}) {
   async function findElement(selector) {
     const element = await querySelector(selector);
     if (!element) return null;
-    return { nodeId: element.objectId, _handle: element };
+    return { objectId: element.objectId, _handle: element };
   }
 
-  async function getBoundingBox(nodeId) {
-    if (!nodeId) return null;
+  async function getBoundingBox(objectId) {
+    if (!objectId) return null;
 
     let result;
     try {
       result = await session.send('Runtime.callFunctionOn', {
-        objectId: nodeId,
+        objectId,
         functionDeclaration: `function() {
           const rect = this.getBoundingClientRect();
           return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };

package/{src → scripts}/dom/fill-executor.js

@@ -134,17 +134,21 @@ export function createFillExecutor(session, elementLocator, inputEmulator, ariaS
         return { filled: true, ref, method: 'react' };
       }
 
-      await session.send('Runtime.callFunctionOn', {
+      const boxAfterScroll = await session.send('Runtime.callFunctionOn', {
         objectId,
         functionDeclaration: `function() {
           this.scrollIntoView({ block: 'center', behavior: 'instant' });
-        }`
+          const rect = this.getBoundingClientRect();
+          return { x: rect.x, y: rect.y, width: rect.width, height: rect.height };
+        }`,
+        returnByValue: true
       });
 
       await sleep(100);
 
-      const x = refInfo.box.x + refInfo.box.width / 2;
-      const y = refInfo.box.y + refInfo.box.height / 2;
+      const box = boxAfterScroll.result?.value || refInfo.box;
+      const x = box.x + box.width / 2;
+      const y = box.y + box.height / 2;
       await inputEmulator.click(x, y);
 
       await session.send('Runtime.callFunctionOn', {

package/{src → scripts}/dom/input-emulator.js

@@ -21,9 +21,11 @@ import { sleep } from '../utils.js';
  * @param {Object} session - CDP session
  * @returns {Object} Input emulator interface
  */
-export function createInputEmulator(session) {
+export function createInputEmulator(session, options = {}) {
   if (!session) throw new Error('CDP session is required');
 
+  const { getFrameContext } = options;
+
   // Transaction-based mouse state
   // Inspired by Puppeteer's CdpMouse
   const mouseState = {
@@ -251,7 +253,7 @@ export function createInputEmulator(session) {
 
     // Trigger synthetic input event for framework bindings (React, Vue, etc.)
     if (dispatchEvents) {
-      await session.send('Runtime.evaluate', {
+      const evalParams = {
         expression: `
           (function() {
             const el = document.activeElement;
@@ -261,7 +263,12 @@ export function createInputEmulator(session) {
             }
           })()
         `
-      });
+      };
+      if (getFrameContext) {
+        const contextId = getFrameContext();
+        if (contextId) evalParams.contextId = contextId;
+      }
+      await session.send('Runtime.evaluate', evalParams);
     }
   }
 
@@ -277,20 +284,42 @@ export function createInputEmulator(session) {
     await type(text, opts);
   }
 
+  // Mapping of Meta+key combos to macOS editing commands (sent via CDP commands param)
+  const MAC_COMMANDS = {
+    'a': ['selectAll'], 'c': ['copy'], 'v': ['paste'], 'x': ['cut'],
+    'z': ['undo'],
+  };
+  const MAC_SHIFT_COMMANDS = {
+    'z': ['redo'],
+  };
+
   async function press(key, opts = {}) {
-    const { modifiers = {}, delay = 0 } = opts;
+    const { modifiers = {}, delay = 0, commands } = opts;
     const keyDef = KEY_DEFINITIONS[key] || getKeyDefinition(key);
     const modifierFlags = calculateModifiers(modifiers);
 
-    await session.send('Input.dispatchKeyEvent', {
+    // Resolve commands: explicit > auto-detect for Meta combos on macOS
+    const resolvedCommands = commands
+      || (modifiers.meta && modifiers.shift && MAC_SHIFT_COMMANDS[keyDef.key])
+      || (modifiers.meta && MAC_COMMANDS[keyDef.key])
+      || undefined;
+
+    const keyDown = {
       type: 'rawKeyDown',
       key: keyDef.key,
       code: keyDef.code,
       windowsVirtualKeyCode: keyDef.keyCode,
+      nativeVirtualKeyCode: keyDef.keyCode,
       modifiers: modifierFlags
-    });
+    };
+    if (resolvedCommands) keyDown.commands = resolvedCommands;
+
+    await session.send('Input.dispatchKeyEvent', keyDown);
 
-    if (keyDef.text) {
+    // Skip char event when command modifiers are held (shortcuts shouldn't produce text)
+    // Shift alone still produces text (e.g., Shift+a → "A")
+    const hasCommandModifier = modifiers.ctrl || modifiers.meta || modifiers.alt;
+    if (keyDef.text && !hasCommandModifier) {
       await session.send('Input.dispatchKeyEvent', {
         type: 'char',
         text: keyDef.text,
@@ -306,12 +335,13 @@ export function createInputEmulator(session) {
       key: keyDef.key,
       code: keyDef.code,
       windowsVirtualKeyCode: keyDef.keyCode,
+      nativeVirtualKeyCode: keyDef.keyCode,
       modifiers: modifierFlags
     });
   }
 
   async function selectAll() {
-    await session.send('Runtime.evaluate', {
+    const evalParams = {
       expression: `
         (function() {
           const el = document.activeElement;
@@ -322,7 +352,12 @@ export function createInputEmulator(session) {
           }
         })()
       `
-    });
+    };
+    if (getFrameContext) {
+      const contextId = getFrameContext();
+      if (contextId) evalParams.contextId = contextId;
+    }
+    await session.send('Runtime.evaluate', evalParams);
   }
 
   async function moveMouse(x, y) {
@@ -342,6 +377,9 @@ export function createInputEmulator(session) {
       y
     });
 
+    mouseState.x = x;
+    mouseState.y = y;
+
     if (duration > 0) {
       await sleep(duration);
     }

package/{src → scripts}/dom/react-filler.js

@@ -27,8 +27,11 @@ export function createReactInputFiller(session) {
         const prototype = el.tagName === 'TEXTAREA'
           ? window.HTMLTextAreaElement.prototype
           : window.HTMLInputElement.prototype;
-        const nativeValueSetter = Object.getOwnPropertyDescriptor(prototype, 'value').set;
-        nativeValueSetter.call(el, newValue);
+        const descriptor = Object.getOwnPropertyDescriptor(prototype, 'value');
+        if (!descriptor || !descriptor.set) {
+          return { success: false, error: 'Cannot get native value setter for ' + el.tagName };
+        }
+        descriptor.set.call(el, newValue);
         el.dispatchEvent(new Event('input', { bubbles: true }));
         el.dispatchEvent(new Event('change', { bubbles: true }));
         return { success: true, value: el.value };
@@ -44,7 +47,12 @@ export function createReactInputFiller(session) {
       throw new Error(`React fill failed: ${errorText}`);
     }
 
-    return result.result.value;
+    const fillResult = result.result.value;
+    if (fillResult && fillResult.success === false) {
+      throw new Error(`React fill failed: ${fillResult.error}`);
+    }
+
+    return fillResult;
   }
 
   async function fillBySelector(selector, value) {

package/{src → scripts}/dom/wait-executor.js

@@ -197,6 +197,7 @@ export function createWaitExecutor(session, elementLocator) {
   async function waitForText(text, opts = {}) {
     const { timeout = DEFAULT_TIMEOUT, caseSensitive = false } = opts;
     const validatedTimeout = validateTimeout(timeout);
+    const waitStartTime = Date.now();
 
     try {
       // Use browser-side polling with MutationObserver
@@ -270,13 +271,20 @@ export function createWaitExecutor(session, elementLocator) {
 
       return result.result.value;
     } catch (error) {
-      // Fall back to original Node.js polling
+      // Fall back to original Node.js polling using remaining time from overall timeout
+      const elapsed = Date.now() - waitStartTime;
+      const remaining = validatedTimeout - elapsed;
+      if (remaining <= 0) {
+        throw timeoutError(
+          `Timeout (${validatedTimeout}ms) waiting for text: "${text}"${caseSensitive ? ' (case-sensitive)' : ''}`
+        );
+      }
       const startTime = Date.now();
       const checkExpr = caseSensitive
         ? `document.body.innerText.includes(${JSON.stringify(text)})`
         : `document.body.innerText.toLowerCase().includes(${JSON.stringify(text.toLowerCase())})`;
 
-      while (Date.now() - startTime < validatedTimeout) {
+      while (Date.now() - startTime < remaining) {
         try {
           const result = await session.send('Runtime.evaluate', {
             expression: checkExpr,

package/{src → scripts}/page/dialog-handler.js

@@ -32,9 +32,13 @@ export function createDialogHandler(session) {
       promptText = queued.promptText;
     } else if (dialogCallback) {
       // If custom callback is set, use it
-      const result = dialogCallback({ type, message, defaultPrompt });
-      accept = result.accept !== false;
-      promptText = result.promptText;
+      try {
+        const result = dialogCallback({ type, message, defaultPrompt });
+        accept = result.accept !== false;
+        promptText = result.promptText;
+      } catch {
+        // Callback threw — fall through to default accept behavior
+      }
     } else {
       // Auto-accept with reasonable defaults for prompts
       if (type === 'prompt') {

package/{src → scripts}/page/dom-stability.js

@@ -24,16 +24,23 @@ export function lcsLength(a, b) {
   const m = a.length;
   const n = b.length;
 
-  // Use space-optimized version for large arrays
-  if (m > 1000 || n > 1000) {
-    // For very large arrays, use a simpler similarity metric
-    const setA = new Set(a);
-    const setB = new Set(b);
-    let common = 0;
-    for (const item of setA) {
-      if (setB.has(item)) common++;
-    }
-    return common;
+  // For large arrays, sample evenly to keep DP tractable while preserving order
+  const MAX_DP = 1000;
+  if (m > MAX_DP || n > MAX_DP) {
+    const sampleEvenly = (arr, size) => {
+      if (arr.length <= size) return arr;
+      const step = arr.length / size;
+      const sampled = [];
+      for (let i = 0; i < size; i++) {
+        sampled.push(arr[Math.floor(i * step)]);
+      }
+      return sampled;
+    };
+    const sampledA = sampleEvenly(a, MAX_DP);
+    const sampledB = sampleEvenly(b, MAX_DP);
+    const lcs = lcsLength(sampledA, sampledB);
+    // Scale result back to original array size
+    return Math.round(lcs * Math.max(m, n) / MAX_DP);
   }
 
   // Standard DP solution