cdp-skill 1.0.8 → 1.0.14

package/src/tests/FillExecutor.test.js

@@ -311,14 +311,14 @@ describe('FillExecutor', () => {
     it('should throw if params is not an object', async () => {
       await assert.rejects(
         () => executor.executeBatch(null),
-        { message: 'fillForm requires an object mapping selectors to values' }
+        { message: 'fill batch requires an object mapping selectors to values' }
       );
     });
 
     it('should throw if no fields provided', async () => {
       await assert.rejects(
         () => executor.executeBatch({}),
-        { message: 'fillForm requires at least one field' }
+        { message: 'fill batch requires at least one field' }
       );
     });
 

package/src/tests/StepValidator.test.js

@@ -60,14 +60,9 @@ describe('StepValidator', () => {
     });
 
     describe('wait validation', () => {
-      it('should accept numeric wait (delay)', () => {
+      it('should reject numeric wait — use sleep instead', () => {
         const errors = validateStepInternal({ wait: 1000 });
-        assert.strictEqual(errors.length, 0);
-      });
-
-      it('should reject negative wait time', () => {
-        const errors = validateStepInternal({ wait: -100 });
-        assert.ok(errors.some(e => e.includes('non-negative')));
+        assert.ok(errors.some(e => e.includes('sleep')));
       });
 
       it('should accept string selector', () => {
@@ -95,9 +90,9 @@ describe('StepValidator', () => {
         assert.strictEqual(errors.length, 0);
       });
 
-      it('should accept object with time', () => {
+      it('should reject object with time — use sleep instead', () => {
         const errors = validateStepInternal({ wait: { time: 500 } });
-        assert.strictEqual(errors.length, 0);
+        assert.ok(errors.some(e => e.includes('sleep')));
       });
 
       it('should accept object with urlContains', () => {
@@ -107,7 +102,7 @@ describe('StepValidator', () => {
 
       it('should reject object without required fields', () => {
         const errors = validateStepInternal({ wait: { timeout: 1000 } });
-        assert.ok(errors.some(e => e.includes('requires selector, text, textRegex, time, or urlContains')));
+        assert.ok(errors.some(e => e.includes('requires selector, text, textRegex, or urlContains')));
       });
 
       it('should reject non-string selector in object', () => {
@@ -131,6 +126,33 @@ describe('StepValidator', () => {
       });
     });
 
+    describe('sleep validation', () => {
+      it('should accept valid sleep', () => {
+        const errors = validateStepInternal({ sleep: 2000 });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      it('should accept zero', () => {
+        const errors = validateStepInternal({ sleep: 0 });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      it('should reject negative', () => {
+        const errors = validateStepInternal({ sleep: -100 });
+        assert.ok(errors.some(e => e.includes('non-negative')));
+      });
+
+      it('should reject over 60000', () => {
+        const errors = validateStepInternal({ sleep: 90000 });
+        assert.ok(errors.some(e => e.includes('60000')));
+      });
+
+      it('should reject non-number', () => {
+        const errors = validateStepInternal({ sleep: '1000' });
+        assert.ok(errors.some(e => e.includes('number')));
+      });
+    });
+
     describe('click validation', () => {
       it('should accept string selector', () => {
         const errors = validateStepInternal({ click: '#button' });
@@ -188,7 +210,14 @@ describe('StepValidator', () => {
       });
     });
 
-    describe('fill validation', () => {
+    describe('fill validation (unified)', () => {
+      // Shape 1: focused mode (string)
+      it('should accept string for focused mode', () => {
+        const errors = validateStepInternal({ fill: 'hello world' });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      // Shape 2: single field with targeting
       it('should accept object with selector and value', () => {
         const errors = validateStepInternal({ fill: { selector: '#input', value: 'test' } });
         assert.strictEqual(errors.length, 0);
@@ -204,17 +233,7 @@ describe('StepValidator', () => {
         assert.strictEqual(errors.length, 0);
       });
 
-      it('should reject non-object fill', () => {
-        const errors = validateStepInternal({ fill: 'value' });
-        assert.ok(errors.some(e => e.includes('requires an object')));
-      });
-
-      it('should reject missing selector/ref/label', () => {
-        const errors = validateStepInternal({ fill: { value: 'test' } });
-        assert.ok(errors.some(e => e.includes('requires selector, ref, or label')));
-      });
-
-      it('should reject missing value', () => {
+      it('should reject missing value with targeting', () => {
         const errors = validateStepInternal({ fill: { selector: '#input' } });
         assert.ok(errors.some(e => e.includes('requires value')));
       });
@@ -223,17 +242,17 @@ describe('StepValidator', () => {
         const errors = validateStepInternal({ fill: { selector: 123, value: 'test' } });
         assert.ok(errors.some(e => e.includes('selector must be a string')));
       });
-    });
 
-    describe('fillForm validation', () => {
-      it('should accept simple format', () => {
-        const errors = validateStepInternal({ fillForm: { '#a': 'value1', '#b': 'value2' } });
+      // Shape 3: focused with options
+      it('should accept object with value only (focused mode)', () => {
+        const errors = validateStepInternal({ fill: { value: 'test', clear: true } });
         assert.strictEqual(errors.length, 0);
       });
 
-      it('should accept extended format', () => {
+      // Shape 4: batch with fields
+      it('should accept batch with fields key', () => {
         const errors = validateStepInternal({
-          fillForm: {
+          fill: {
             fields: { '#a': 'value1' },
             react: true
           }
@@ -241,25 +260,36 @@ describe('StepValidator', () => {
         assert.strictEqual(errors.length, 0);
       });
 
-      it('should reject non-object fillForm', () => {
-        const errors = validateStepInternal({ fillForm: 'invalid' });
-        assert.ok(errors.some(e => e.includes('requires an object')));
-      });
-
       it('should reject empty fields', () => {
-        const errors = validateStepInternal({ fillForm: {} });
+        const errors = validateStepInternal({ fill: { fields: {} } });
         assert.ok(errors.some(e => e.includes('requires at least one field')));
       });
 
       it('should validate react option as boolean', () => {
         const errors = validateStepInternal({
-          fillForm: {
+          fill: {
             fields: { '#a': 'val' },
             react: 'yes'
           }
         });
         assert.ok(errors.some(e => e.includes('react option must be a boolean')));
       });
+
+      // Shape 5: batch (plain mapping)
+      it('should accept plain mapping batch', () => {
+        const errors = validateStepInternal({ fill: { '#a': 'value1', '#b': 'value2' } });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      it('should reject empty plain mapping', () => {
+        const errors = validateStepInternal({ fill: {} });
+        assert.ok(errors.some(e => e.includes('requires at least one field')));
+      });
+
+      it('should reject non-string/non-object fill', () => {
+        const errors = validateStepInternal({ fill: 123 });
+        assert.ok(errors.some(e => e.includes('requires a string')));
+      });
     });
 
     describe('press validation', () => {
@@ -414,84 +444,162 @@ describe('StepValidator', () => {
       });
     });
 
-    describe('getBox validation', () => {
-      it('should accept single ref string', () => {
-        const errors = validateStepInternal({ getBox: 's1e1' });
+    describe('elementsAt validation (unified)', () => {
+      // Point mode (was refAt)
+      it('should accept single point object', () => {
+        const errors = validateStepInternal({ elementsAt: { x: 100, y: 200 } });
         assert.strictEqual(errors.length, 0);
       });
 
-      it('should accept array of refs', () => {
-        const errors = validateStepInternal({ getBox: ['s1e1', 's1e2', 's2e3'] });
-        assert.strictEqual(errors.length, 0);
+      it('should reject missing x in point mode', () => {
+        const errors = validateStepInternal({ elementsAt: { y: 200 } });
+        assert.ok(errors.some(e => e.includes('requires x coordinate')));
+      });
+
+      it('should reject missing y in point mode', () => {
+        const errors = validateStepInternal({ elementsAt: { x: 100 } });
+        assert.ok(errors.some(e => e.includes('requires y coordinate')));
       });
 
-      it('should reject invalid ref format', () => {
-        const errors = validateStepInternal({ getBox: 'invalid' });
-        assert.ok(errors.some(e => e.includes('format "s{N}e{M}"')));
+      // Batch mode (was elementsAt array)
+      it('should accept array of coordinates', () => {
+        const errors = validateStepInternal({ elementsAt: [{ x: 100, y: 200 }] });
+        assert.strictEqual(errors.length, 0);
       });
 
       it('should reject empty array', () => {
-        const errors = validateStepInternal({ getBox: [] });
+        const errors = validateStepInternal({ elementsAt: [] });
         assert.ok(errors.some(e => e.includes('cannot be empty')));
       });
+
+      it('should reject invalid coordinates in array', () => {
+        const errors = validateStepInternal({ elementsAt: [{ x: 'abc', y: 200 }] });
+        assert.ok(errors.some(e => e.includes('requires x and y as numbers')));
+      });
+
+      // Near mode (was elementsNear)
+      it('should accept object with radius', () => {
+        const errors = validateStepInternal({ elementsAt: { x: 100, y: 200, radius: 50 } });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      it('should reject non-numeric radius', () => {
+        const errors = validateStepInternal({ elementsAt: { x: 100, y: 200, radius: 'large' } });
+        assert.ok(errors.some(e => e.includes('radius must be a number')));
+      });
     });
 
-    describe('refAt validation', () => {
-      it('should accept valid coordinates', () => {
-        const errors = validateStepInternal({ refAt: { x: 100, y: 200 } });
+    describe('frame validation', () => {
+      it('should accept "top" (main frame)', () => {
+        const errors = validateStepInternal({ frame: 'top' });
         assert.strictEqual(errors.length, 0);
       });
 
-      it('should reject missing x', () => {
-        const errors = validateStepInternal({ refAt: { y: 200 } });
-        assert.ok(errors.some(e => e.includes('requires x coordinate')));
+      it('should accept CSS selector string', () => {
+        const errors = validateStepInternal({ frame: 'iframe.content' });
+        assert.strictEqual(errors.length, 0);
       });
 
-      it('should reject missing y', () => {
-        const errors = validateStepInternal({ refAt: { x: 100 } });
-        assert.ok(errors.some(e => e.includes('requires y coordinate')));
+      it('should accept numeric index', () => {
+        const errors = validateStepInternal({ frame: 0 });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      it('should accept {list: true}', () => {
+        const errors = validateStepInternal({ frame: { list: true } });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      it('should accept {name: "foo"}', () => {
+        const errors = validateStepInternal({ frame: { name: 'myFrame' } });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      it('should reject empty string', () => {
+        const errors = validateStepInternal({ frame: '' });
+        assert.ok(errors.some(e => e.includes('non-empty')));
+      });
+
+      it('should reject negative index', () => {
+        const errors = validateStepInternal({ frame: -1 });
+        assert.ok(errors.some(e => e.includes('non-negative')));
+      });
+
+      it('should reject null', () => {
+        const errors = validateStepInternal({ frame: null });
+        assert.ok(errors.some(e => e.includes('requires')));
       });
     });
+  });
 
-    describe('elementsAt validation', () => {
-      it('should accept array of coordinates', () => {
-        const errors = validateStepInternal({ elementsAt: [{ x: 100, y: 200 }] });
+    describe('newTab validation', () => {
+      it('should accept true', () => {
+        const errors = validateStepInternal({ newTab: true });
         assert.strictEqual(errors.length, 0);
       });
 
-      it('should reject non-array', () => {
-        const errors = validateStepInternal({ elementsAt: { x: 100, y: 200 } });
-        assert.ok(errors.some(e => e.includes('requires an array')));
+      it('should accept URL string', () => {
+        const errors = validateStepInternal({ newTab: 'https://example.com' });
+        assert.strictEqual(errors.length, 0);
       });
 
-      it('should reject empty array', () => {
-        const errors = validateStepInternal({ elementsAt: [] });
-        assert.ok(errors.some(e => e.includes('cannot be empty')));
+      it('should accept object with url', () => {
+        const errors = validateStepInternal({ newTab: { url: 'https://example.com' } });
+        assert.strictEqual(errors.length, 0);
       });
 
-      it('should reject invalid coordinates in array', () => {
-        const errors = validateStepInternal({ elementsAt: [{ x: 'abc', y: 200 }] });
-        assert.ok(errors.some(e => e.includes('requires x and y as numbers')));
+      it('should accept object with connection params', () => {
+        const errors = validateStepInternal({ newTab: { url: 'https://example.com', host: 'remote', port: 9333, headless: true } });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      it('should reject non-string host', () => {
+        const errors = validateStepInternal({ newTab: { url: 'https://example.com', host: 123 } });
+        assert.ok(errors.some(e => e.includes('host must be a string')));
+      });
+
+      it('should reject non-number port', () => {
+        const errors = validateStepInternal({ newTab: { url: 'https://example.com', port: '9222' } });
+        assert.ok(errors.some(e => e.includes('port must be a number')));
+      });
+
+      it('should reject non-boolean headless', () => {
+        const errors = validateStepInternal({ newTab: { url: 'https://example.com', headless: 'yes' } });
+        assert.ok(errors.some(e => e.includes('headless must be a boolean')));
       });
     });
 
-    describe('elementsNear validation', () => {
-      it('should accept valid coordinates', () => {
-        const errors = validateStepInternal({ elementsNear: { x: 100, y: 200 } });
+    describe('switchTab validation', () => {
+      it('should accept string alias', () => {
+        const errors = validateStepInternal({ switchTab: 't1' });
         assert.strictEqual(errors.length, 0);
       });
 
-      it('should accept with radius', () => {
-        const errors = validateStepInternal({ elementsNear: { x: 100, y: 200, radius: 50 } });
+      it('should accept object with targetId', () => {
+        const errors = validateStepInternal({ switchTab: { targetId: 'ABC123' } });
         assert.strictEqual(errors.length, 0);
       });
 
-      it('should reject non-numeric radius', () => {
-        const errors = validateStepInternal({ elementsNear: { x: 100, y: 200, radius: 'large' } });
-        assert.ok(errors.some(e => e.includes('radius must be a number')));
+      it('should accept object with url', () => {
+        const errors = validateStepInternal({ switchTab: { url: 'example\\.com' } });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      it('should accept object with connection params', () => {
+        const errors = validateStepInternal({ switchTab: { targetId: 'ABC', host: 'remote', port: 9333 } });
+        assert.strictEqual(errors.length, 0);
+      });
+
+      it('should reject non-string host', () => {
+        const errors = validateStepInternal({ switchTab: { targetId: 'ABC', host: 123 } });
+        assert.ok(errors.some(e => e.includes('host must be a string')));
+      });
+
+      it('should reject non-number port', () => {
+        const errors = validateStepInternal({ switchTab: { targetId: 'ABC', port: '9222' } });
+        assert.ok(errors.some(e => e.includes('port must be a number')));
       });
     });
-  });
 
   describe('validateSteps', () => {
     it('should return valid for empty array', () => {
@@ -529,10 +637,48 @@ describe('StepValidator', () => {
 
     it('should include all validation errors for each step', () => {
       const result = validateSteps([
-        { fill: {} }  // Missing both selector and value
+        { fill: { selector: 123, value: undefined } }  // Bad selector type and missing value
       ]);
       assert.strictEqual(result.valid, false);
       assert.ok(result.errors[0].errors.length >= 2);
     });
   });
+
+  describe('null pointer crash fixes', () => {
+    it('should not crash on reload with null params', () => {
+      const errors = validateStepInternal({ reload: null });
+      // Should reject but not crash
+      assert.ok(errors.some(e => e.includes('requires true or params object')));
+    });
+
+    it('should not crash on snapshot with null params', () => {
+      const errors = validateStepInternal({ snapshot: null });
+      // Should reject but not crash
+      assert.ok(errors.some(e => e.includes('requires true or params object')));
+    });
+
+    it('should not crash on waitForNavigation with null params', () => {
+      const errors = validateStepInternal({ waitForNavigation: null });
+      // Should reject but not crash
+      assert.ok(errors.some(e => e.includes('requires true or params object')));
+    });
+
+    it('should handle reload with null params object properties', () => {
+      const errors = validateStepInternal({ reload: { waitUntil: undefined } });
+      // Should accept (waitUntil is optional)
+      assert.strictEqual(errors.length, 0);
+    });
+
+    it('should handle snapshot with null params object properties', () => {
+      const errors = validateStepInternal({ snapshot: { mode: 'ai' } });
+      // Should accept valid mode
+      assert.strictEqual(errors.length, 0);
+    });
+
+    it('should handle waitForNavigation with null timeout', () => {
+      const errors = validateStepInternal({ waitForNavigation: { timeout: undefined } });
+      // Should accept (timeout is optional)
+      assert.strictEqual(errors.length, 0);
+    });
+  });
 });

package/src/tests/TestRunner.test.js

@@ -27,6 +27,17 @@ describe('TestRunner', () => {
     mockPageController = {
       navigate: mock.fn(() => Promise.resolve()),
       getUrl: mock.fn(() => Promise.resolve('http://test.com')),
+      evaluateInFrame: mock.fn((expression, options = {}) => {
+        // Delegate to session.send with same behavior as real evaluateInFrame
+        const params = {
+          expression,
+          returnByValue: options.returnByValue !== false,
+          awaitPromise: options.awaitPromise || false
+        };
+        return mockPageController.session.send('Runtime.evaluate', params);
+      }),
+      getFrameContext: mock.fn(() => null),
+      waitForNetworkSettle: mock.fn(() => Promise.resolve({ settled: true, pendingCount: 0 })),
       session: { send: null } // Will be set after mockElementLocator is created
     };
 
@@ -389,11 +400,12 @@ describe('TestRunner', () => {
       assert.strictEqual(mockInputEmulator.insertText.mock.calls.length, 1);
     });
 
-    it('should fail without selector, ref, or label', async () => {
+    it('should accept fill with value only as focused mode', async () => {
+      // fill: {value: "test"} is now focused mode (Shape 3), not an error
+      // It requires an active focused element to work, but validation passes
       const result = await testRunner.executeStep({ fill: { value: 'test' } });
-
-      assert.strictEqual(result.status, 'error');
-      assert.ok(result.error.includes('Fill requires selector, ref, or label'));
+      // May error at runtime if no element is focused, but that's a runtime error, not validation
+      assert.ok(result.action === 'fill');
     });
 
     it('should fail without value', async () => {
@@ -478,7 +490,7 @@ describe('TestRunner', () => {
         { wait: '#main' },
         { wait: { selector: '#element', timeout: 5000 } },
         { wait: { text: 'Hello', timeout: 3000 } },
-        { wait: { time: 100 } },
+        { sleep: 100 },
         { click: '#button' },
         { click: { selector: '#link' } },
         { fill: { selector: '#input', value: 'test' } },
@@ -539,15 +551,15 @@ describe('TestRunner', () => {
 
       const result = testRunner.validateSteps(steps);
       assert.strictEqual(result.valid, false);
-      assert.ok(result.errors[0].errors[0].includes('selector, text, textRegex, time, or urlContains'));
+      assert.ok(result.errors[0].errors[0].includes('requires selector, text, textRegex, or urlContains'));
     });
 
-    it('should return errors for negative wait time', () => {
+    it('should return errors for wait with time — use sleep instead', () => {
       const steps = [{ wait: { time: -100 } }];
 
       const result = testRunner.validateSteps(steps);
       assert.strictEqual(result.valid, false);
-      assert.ok(result.errors[0].errors[0].includes('non-negative number'));
+      assert.ok(result.errors[0].errors.some(e => e.includes('sleep')));
     });
 
     it('should return errors for empty click selector', () => {
@@ -566,15 +578,15 @@ describe('TestRunner', () => {
       assert.ok(result.errors[0].errors[0].includes('requires selector'));
     });
 
-    it('should return errors for fill without selector, ref, or label', () => {
+    it('should accept fill with value only as focused mode', () => {
+      // fill: {value: "test"} is now Shape 3: focused with options
       const steps = [{ fill: { value: 'test' } }];
 
       const result = testRunner.validateSteps(steps);
-      assert.strictEqual(result.valid, false);
-      assert.ok(result.errors[0].errors.some(e => e.includes('requires selector, ref, or label')));
+      assert.strictEqual(result.valid, true);
     });
 
-    it('should return errors for fill without value', () => {
+    it('should return errors for fill without value when targeting', () => {
       const steps = [{ fill: { selector: '#input' } }];
 
       const result = testRunner.validateSteps(steps);
@@ -582,12 +594,12 @@ describe('TestRunner', () => {
       assert.ok(result.errors[0].errors.some(e => e.includes('requires value')));
     });
 
-    it('should return errors for fill with non-object', () => {
+    it('should accept fill with string as focused mode', () => {
+      // fill: "text" is now Shape 1: focused mode
       const steps = [{ fill: '#input' }];
 
       const result = testRunner.validateSteps(steps);
-      assert.strictEqual(result.valid, false);
-      assert.ok(result.errors[0].errors[0].includes('object with selector/ref/label and value'));
+      assert.strictEqual(result.valid, true);
     });
 
     it('should accept fill with ref instead of selector', () => {
@@ -597,27 +609,26 @@ describe('TestRunner', () => {
       assert.strictEqual(result.valid, true);
     });
 
-    it('should validate fillForm step', () => {
-      const steps = [{ fillForm: { '#firstName': 'John', '#lastName': 'Doe' } }];
+    it('should validate fill batch step (was fillForm)', () => {
+      const steps = [{ fill: { '#firstName': 'John', '#lastName': 'Doe' } }];
 
       const result = testRunner.validateSteps(steps);
       assert.strictEqual(result.valid, true);
     });
 
-    it('should return errors for empty fillForm', () => {
-      const steps = [{ fillForm: {} }];
+    it('should return errors for empty fill batch', () => {
+      const steps = [{ fill: {} }];
 
       const result = testRunner.validateSteps(steps);
       assert.strictEqual(result.valid, false);
       assert.ok(result.errors[0].errors[0].includes('at least one field'));
     });
 
-    it('should return errors for fillForm with non-object', () => {
-      const steps = [{ fillForm: '#input' }];
+    it('should validate fill focused mode (string)', () => {
+      const steps = [{ fill: 'hello world' }];
 
       const result = testRunner.validateSteps(steps);
-      assert.strictEqual(result.valid, false);
-      assert.ok(result.errors[0].errors[0].includes('object mapping'));
+      assert.strictEqual(result.valid, true);
     });
 
     it('should return errors for empty press key', () => {
@@ -715,10 +726,10 @@ describe('TestRunner', () => {
       assert.ok(result.errors[0].errors[0].includes('cannot be empty'));
     });
 
-    it('should reject hover without selector or ref', () => {
+    it('should reject hover without selector, ref, text, or coordinates', () => {
       const result = validateSteps([{ hover: { duration: 500 } }]);
       assert.strictEqual(result.valid, false);
-      assert.ok(result.errors[0].errors[0].includes('requires selector or ref'));
+      assert.ok(result.errors[0].errors[0].includes('requires selector, ref, text, or x/y'));
     });
   });
 

package/src/tests/integration.test.js

@@ -296,7 +296,8 @@ describe('Integration: Component Instantiation', () => {
 describe('Integration: TestRunner with Mocks', () => {
   it('should work with mock dependencies', async () => {
     const mockPageController = {
-      navigate: async () => {}
+      navigate: async () => {},
+      waitForNetworkSettle: async () => ({ settled: true, pendingCount: 0 })
     };
 
     // Create a full mock handle with stability/scroll methods

package/src/types.js

@@ -217,27 +217,27 @@
  * Step configuration
  * @typedef {Object} StepConfig
  * @property {string} [goto] - Navigate to URL
- * @property {string} [click] - Click element selector
- * @property {string} [fill] - Fill element selector
- * @property {string} [value] - Value for fill/type operations
+ * @property {string} [click] - Click element (selector, ref, text, or x/y)
+ * @property {string|Object} [fill] - Fill input: string (focused), {selector,value} (single), {fields} or mapping (batch)
  * @property {string} [type] - Type into element
  * @property {string} [press] - Press key(s)
  * @property {Object} [scroll] - Scroll configuration
  * @property {boolean|Object} [snapshot] - Take ARIA snapshot
  * @property {string|Object} [query] - Query elements
- * @property {string} [hover] - Hover over element
- * @property {Object} [wait] - Wait configuration
- * @property {string} [eval] - Evaluate JavaScript
- * @property {string|Object} [openTab] - Open new tab
+ * @property {string|Object} [hover] - Hover over element (selector, ref, text, or x/y)
+ * @property {string|Object} [wait] - Wait for selector/text/urlContains (no time delay — use sleep)
+ * @property {number} [sleep] - Time delay in ms (0–60000)
+ * @property {string|Object} [pageFunction] - Execute JS: function expression or bare expression
+ * @property {true|string|{url?: string, host?: string, port?: number, headless?: boolean}} [openTab] - Open new tab
  * @property {string} [closeTab] - Close tab by ID
- * @property {boolean|Object} [chromeStatus] - Check/launch Chrome
  * @property {string|Object} [selectOption] - Select dropdown option
  * @property {string|Object} [viewport] - Set viewport
  * @property {Object} [cookies] - Cookie operations
  * @property {boolean} [back] - Navigate back
  * @property {boolean} [forward] - Navigate forward
  * @property {Object} [drag] - Drag and drop
- * @property {Object} [fillForm] - Fill multiple form fields
+ * @property {string|number|Object} [frame] - Frame ops: "selector", index, "top", {name}, {list:true}
+ * @property {Object|Array} [elementsAt] - Coordinate lookup: {x,y} (point), [{x,y},...] (batch), {x,y,radius} (near)
  * @property {Object} [extract] - Extract data from page
  * @property {Object} [formState] - Get form state
  * @property {Object} [assert] - Assert condition