@testdriverai/agent 7.11.229-test → 7.11.231-test

package/docs/options.mdx

@@ -1,33 +1,47 @@
 ---
-title: "Options Reference"
-sidebarTitle: "Options Reference"
-description: "Every option you can pass to the TestDriver client, with defaults and examples"
+title: "Options"
+sidebarTitle: "Options reference"
+description: "Every option you can pass to a TestDriver client, with its default."
 icon: "sliders"
 ---
 
-## Overview
+import { EnterpriseBadge, EnterpriseCta } from '/snippets/enterprise.mdx';
 
-You configure the SDK with an options object. You can pass the object in three places:
+Options control the sandbox, the live preview, the AI, the cache, and redraw detection. A [quick reference](#quick-reference) table at the end lists every option and its default.
+
+## Where to set options
+
+Pass options in any of three places:
 
 ```javascript
-// 1. Vitest hook (most common)
-const testdriver = TestDriver(context, { os: "windows" });
+// 1. The Vitest hook (most common)
+const testdriver = TestDriver(context, { os: 'windows' });
 
-// 2. Constructor
-const testdriver = new TestDriver(apiKey, { os: "windows" });
+// 2. The client constructor
+const testdriver = new TestDriver({ os: 'windows' });
+```
 
-// 3. Global plugin options in vitest.config.mjs
-testdriver({ os: "windows" })
+```javascript vitest.config.mjs
+// 3. The Vitest plugin, for every test in the project
+import { defineConfig } from 'vitest/config';
+import TestDriver from 'testdriverai/vitest';
+
+export default defineConfig({
+  test: {
+    reporters: ['default', TestDriver({ os: 'windows' })],
+    setupFiles: ['testdriverai/vitest/setup'],
+  },
+});
 ```
 
-The hook merges the options in this order. A later source replaces an earlier source:
+When the same option is set in more than one place, the most specific wins:
 
-1. Default values
-2. Environment variables (`TD_OS`, `TD_API_ROOT`, `TD_E2B_TEMPLATE_ID`)
-3. Global plugin options
-4. Options that you pass to the hook or the constructor
+1. Options you pass to the hook or the constructor
+2. Plugin options in `vitest.config`
+3. Environment variables: `TD_OS`, `TD_API_ROOT`, and `TD_E2B_TEMPLATE_ID`
+4. Defaults
 
-Options that you pass to [`connect()`](/client#connect) replace the constructor values for that connection only.
+Options you pass to [`connect()`](/client#connect-options) override the client's values for that connection only.
 
 ## Sandbox
 
@@ -35,36 +49,42 @@ These options control the virtual machine that runs your test.
 
 <ParamField path="os" type="'linux' | 'windows'" default="linux">
   The operating system of the sandbox. You can also set this with the `TD_OS` environment variable.
+
+  <EnterpriseBadge /> `'windows'` is available on Enterprise plans.
 </ParamField>
 
 <ParamField path="resolution" type="string" default="1366x768">
-  The screen resolution of the sandbox. Example: `'1920x1080'`. Custom resolutions are available only on Enterprise plans.
+  The screen resolution of the sandbox, such as `'1920x1080'`.
+
+  <EnterpriseBadge /> Custom resolutions are available on Enterprise plans.
 </ParamField>
 
 <ParamField path="newSandbox" type="boolean" default="true">
-  Create a new sandbox for this run. Set to `false` to reuse a recent sandbox when one is available.
+  Create a new sandbox for this run. Set to `false` to reuse a recent sandbox when one is available. Defaults to `false` when you set `sandboxId` or `reconnect`.
 </ParamField>
 
 <ParamField path="reconnect" type="boolean" default="false">
-  Reattach to the last used sandbox. The SDK reads the sandbox id from `.testdriver/last-sandbox`. The SDK writes this file on every successful connect.
+  Reattach to the last sandbox this project used. The SDK records it in `.testdriver/last-sandbox` on every successful connect.
 
-  When `reconnect` is `true`, the SDK skips provision methods (`chrome`, `vscode`, `installer`, and others). The application is already running. The previous sandbox must still be alive. See [`keepAlive`](#keepalive) and the [Run guide](/copilot/running-tests#keeping-machines-alive-between-runs).
+  While `reconnect` is `true`, provision methods such as `chrome()` and `installer()` are skipped, because the app is already running. The sandbox must still be alive. See [`keepAlive`](#param-keep-alive) and [Reuse a sandbox while you iterate](/copilot/running-tests#reuse-a-sandbox-while-you-iterate).
 </ParamField>
 
 <ParamField path="sandboxId" type="string">
-  Reattach to a specific sandbox id. Use this for CI matrices or to pin a chain of tests to a known VM. This option implies `reconnect: true`. The SDK skips provision calls.
+  Attach to a specific sandbox by its id, for example to pin a chain of tests to one machine. This sets `newSandbox` to `false`.
+
+  Unlike `reconnect`, `sandboxId` alone doesn't skip provision calls. Set `reconnect: true` as well if the app is already running.
 </ParamField>
 
 <ParamField path="keepAlive" type="number" default="60000">
-  The number of milliseconds to keep the sandbox alive after `disconnect()`. Set to `0` to end the sandbox at once. A longer value lets you reconnect to the same sandbox for debugging.
+  The number of milliseconds to keep the sandbox running after `disconnect()`, so you can reconnect to the same sandbox for debugging. Values above 30 minutes are capped at 30 minutes, and `0` uses the default.
 </ParamField>
 
 <ParamField path="debugOnFailure" type="boolean" default="false">
-  Keep the sandbox alive when a test fails. The SDK prints the sandbox id to the console. You can then reconnect with `sandboxId` and debug the failure. This option is available only in the Vitest hook.
+  Keep the sandbox running when a test fails, and print its id so you can reconnect with `sandboxId` and debug. Available only in the Vitest hook.
 </ParamField>
 
 <ParamField path="environment" type="object">
-  Additional environment variables to pass to the sandbox.
+  Extra `TD_*` settings for the SDK itself, as key-value pairs. These configure TestDriver on your machine, not environment variables inside the sandbox. To set variables in the sandbox, run a command with [`exec()`](/exec).
 </ParamField>
 
 ### Example
@@ -86,7 +106,7 @@ These options control what you see while the test runs.
   The preview mode for live test visualization.
 
   - `"browser"` opens the debugger in your default browser.
-  - `"ide"` opens the preview in the IDE panel. This mode needs the TestDriver extension for VS Code or Cursor.
+  - `"ide"` opens the preview in an editor panel. This needs the [TestDriver extension](/quickstart-vscode) for VS Code or Cursor.
   - `"none"` runs without a visual preview. Use this in CI.
 </ParamField>
 
@@ -99,13 +119,11 @@ These options control what you see while the test runs.
 </ParamField>
 
 <ParamField path="autoScreenshots" type="boolean" default="false">
-  Capture a screenshot before and after each command. The SDK saves the screenshots to `.testdriver/screenshots/<test>/`.
-
-  The file name format is `<seq>-<action>-<phase>-L<line>-<description>.png`. Example: `001-click-before-L42-submit-button.png`. See [Debugging with screenshots](/debugging-with-screenshots).
+  Save a screenshot before and after each `testdriver` method call and each `find()`, and when one fails, to `.testdriver/screenshots/<test file>/`. Actions on an element, like `element.click()`, aren't captured. Files are named like `001-find-before-L42-submit-button.png`. See [Screenshots](/screenshots).
 </ParamField>
 
 <ParamField path="logging" type="boolean" default="true">
-  Write SDK logs to the console. You can change this at runtime with [`setLogging()`](/client#setlogging).
+  Write SDK logs to the console. You can change this at runtime with [`setLogging()`](/client#setlogging-enabled).
 </ParamField>
 
 <ParamField path="analytics" type="boolean" default="true">
@@ -126,13 +144,21 @@ const testdriver = TestDriver(context, {
 These options control how the AI locates elements and checks assertions.
 
 <ParamField path="verify" type="boolean" default="false">
-  Run a second AI check on every `find()` result. The check confirms that the coordinates match the requested element. This catches incorrect positions. It adds latency to each call.
+  Double-check every `find()` result with a second AI call. Off by default, because it makes each call slower.
 
-  You can replace this value for one call with `find(description, { verify: true })`. See [find](/find).
+  When on, after the AI locates an element:
+
+  1. A second AI looks at that spot and confirms it's the element you described.
+  2. If it isn't, TestDriver locates the element again with a hint about what was wrong, then checks once more.
+  3. If that check also fails, `find()` returns an element whose `found()` is `false`.
+
+  Results that fail the check are never cached. Results served from the cache aren't re-checked.
+
+  Override it for one call with `find(description, { verify: true })`. See [find()](/find).
 </ParamField>
 
 <ParamField path="ai" type="object">
-  Global AI sampling configuration. These values apply to `find()` verification and to `assert()`. You can replace them for one call with the `ai` option on that call.
+  Global AI sampling configuration. These values apply to `find()` verification and to `assert()`. You can override them for one `assert()` call with its `ai` option. `find()` ignores a per-call `ai` option, so set it here.
 
   <Expandable title="properties">
     <ParamField path="temperature" type="number">
@@ -166,16 +192,14 @@ const testdriver = TestDriver(context, {
 
 ## Caching
 
-These options control the element cache. The cache stores the position of an element after the first `find()`. Later runs reuse the position when the screen has not changed. See [Caching](/caching).
+These options control the element cache, which reuses element positions from a passing run when the screen hasn't changed. See [Caching](/caching).
 
 <ParamField path="cache" type="boolean | object" default="true">
-  Enable or disable the cache. Pass an object to set the match thresholds.
+  Pass `false` to turn the cache off, or an object to set the match thresholds.
 
-  <Expandable title="advanced config">
-    <ParamField path="enabled" type="boolean" default="true">
-      Enable or disable the cache.
-    </ParamField>
+  `cache: { enabled: false }` does not turn the cache off. Use `cache: false` or `TD_NO_CACHE=true`.
 
+  <Expandable title="advanced config">
     <ParamField path="thresholds" type="object">
       Fine-tune the cache matching.
 
@@ -203,7 +227,7 @@ These options control the element cache. The cache stores the position of an ele
 </ParamField>
 
 <ParamField path="cacheKey" type="string">
-  The cache key for element location. When you set a key, the SDK ties the cache to that key. Use a different key for each test to keep the caches separate.
+  The key the cache is stored under. By default, the SDK uses a hash of the test file, so editing the file starts a fresh cache. Set your own key to keep the cache across edits, or to share it between files.
 </ParamField>
 
 <ParamField path="cacheThreshold" type="object">
@@ -215,7 +239,6 @@ These options control the element cache. The cache stores the position of an ele
 ```javascript
 const testdriver = TestDriver(context, {
   cache: {
-    enabled: true,
     thresholds: {
       find: { screen: 0.05, element: 0.8 },
       assert: 0.05,
@@ -227,14 +250,14 @@ const testdriver = TestDriver(context, {
 
 ## Redraw detection
 
-These options control how the SDK waits for the screen to settle after an action. See [Redraw](/redraw).
+These options make the SDK wait for the screen to settle after each action. Redraw detection is off by default. See [Redraw](/redraw).
 
-<ParamField path="redraw" type="boolean | object" default="true">
-  Enable or disable screen-change detection. Pass an object to set the thresholds.
+<ParamField path="redraw" type="boolean | object" default="false">
+  Turn on screen-change detection with `true`, or pass an object to set the thresholds.
 
   <Expandable title="advanced config">
     <ParamField path="enabled" type="boolean" default="true">
-      Enable or disable redraw detection.
+      Whether redraw detection is on when you pass an object.
     </ParamField>
 
     <ParamField path="thresholds" type="object">
@@ -242,7 +265,7 @@ These options control how the SDK waits for the screen to settle after an action
 
       <Expandable title="properties">
         <ParamField path="screen" type="number | false" default="0.05">
-          The pixel diff threshold (0 to 1). Set to `false` to disable screen redraw detection.
+          Set to `false` to turn off screen-change detection and wait only for the network. Any number keeps it on; the number itself isn't used, because the change threshold is fixed.
         </ParamField>
 
         <ParamField path="network" type="boolean" default="false">
@@ -269,7 +292,9 @@ const testdriver = TestDriver(context, {
 
 ## Self-hosted and infrastructure
 
-Most users do not need these options. Use them for self-hosted or custom deployments.
+Most projects don't need these. They're for self-hosted or custom deployments.
+
+<EnterpriseCta feature="Self-hosting" />
 
 <ParamField path="apiRoot" type="string">
   The API endpoint URL. The default depends on the release channel. You can also set this with the `TD_API_ROOT` environment variable.
@@ -277,6 +302,8 @@ Most users do not need these options. Use them for self-hosted or custom deploym
 
 <ParamField path="ip" type="string">
   The IP address of a running sandbox. The SDK connects to this address directly.
+
+  <EnterpriseBadge /> Connecting to your own machines is available on Enterprise plans.
 </ParamField>
 
 <ParamField path="sandboxAmi" type="string">
@@ -312,7 +339,7 @@ Most users do not need these options. Use them for self-hosted or custom deploym
 | `ai` | `object` | — |
 | `cache` | `boolean \| object` | `true` |
 | `cacheKey` | `string` | — |
-| `redraw` | `boolean \| object` | `true` |
+| `redraw` | `boolean \| object` | `false` |
 | `apiRoot` | `string` | channel default |
 | `ip` | `string` | — |
 | `sandboxAmi` | `string` | — |

package/docs/parse.mdx

@@ -1,237 +1,148 @@
 ---
 title: "parse()"
 sidebarTitle: "parse"
-description: "Detect all UI elements on screen using OmniParser"
+description: "List every UI element on screen, with its type, text, and position."
 icon: "diagram-project"
 ---
 
-## Overview
+Detect every element on the current screen and get back a list with each one's type, text, and position.
 
-Parse the screen with OmniParser v2 to find all visible UI elements. TestDriver returns structured data. This includes element types, text content, interactivity levels, and bounding box coordinates.
+```javascript
+const { elements } = await testdriver.parse();
+console.log(`Found ${elements.length} elements`);
+```
+
+`parse()` uses [OmniParser v2](https://github.com/microsoft/OmniParser). It works from the screenshot alone, so it doesn't need a DOM or accessibility tree.
 
-This method examines all of the screen and returns each element that it finds. Use it for these:
-- To understand the full UI layout of a screen
-- To find all clickable or interactive elements
-- To build custom element logic
-- To debug which elements TestDriver can find
-- To do an accessibility audit
+To act on one specific element, use [`find()`](/find) instead. Use `parse()` when you need an inventory of the whole screen.
 
 <Note>
-  **Availability**: `parse()` needs an enterprise plan or a self-hosted plan. It uses OmniParser v2 on the server for element detection.
+  `parse()` requires an Enterprise or self-hosted plan.
 </Note>
 
-## Syntax
+## Signature
 
-```javascript
-const result = await testdriver.parse()
+```typescript
+testdriver.parse(): Promise<ParseResult>
 ```
 
 ## Parameters
 
-None.
+None. `parse()` analyzes the screen as it is when you call it.
 
 ## Returns
 
-`Promise<ParseResult>` - Object containing detected UI elements
-
-### ParseResult
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `elements` | `ParsedElement[]` | Array of detected UI elements |
-| `annotatedImageUrl` | `string` | URL of the annotated screenshot with bounding boxes |
-| `imageWidth` | `number` | Width of the analyzed screenshot |
-| `imageHeight` | `number` | Height of the analyzed screenshot |
-
-### ParsedElement
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `index` | `number` | Element index |
-| `type` | `string` | Element type (e.g. `"text"`, `"icon"`, `"button"`) |
-| `content` | `string` | Text content or description of the element |
-| `interactivity` | `string` | Interactivity level (e.g. `"clickable"`, `"non-interactive"`) |
-| `bbox` | `object` | Bounding box in pixel coordinates `{x0, y0, x1, y1}` |
-| `boundingBox` | `object` | Bounding box as `{left, top, width, height}` |
+<ResponseField name="ParseResult" type="object">
+  <Expandable title="properties">
+    <ResponseField name="elements" type="ParsedElement[]">
+      One entry per detected element.
+      <Expandable title="ParsedElement">
+        <ResponseField name="index" type="number">
+          The element's position in the list, starting at `0`.
+        </ResponseField>
+        <ResponseField name="type" type="string">
+          What OmniParser detected, such as `'text'` or `'icon'`.
+        </ResponseField>
+        <ResponseField name="content" type="string">
+          The element's text, or a short description of an icon.
+        </ResponseField>
+        <ResponseField name="interactivity" type="boolean">
+          `true` when OmniParser thinks the element can be clicked.
+        </ResponseField>
+        <ResponseField name="bbox" type="object">
+          The corners in pixels: `{ x0, y0, x1, y1 }`, where `(x0, y0)` is top-left and `(x1, y1)` is bottom-right.
+        </ResponseField>
+        <ResponseField name="boundingBox" type="object">
+          The same box as `{ left, top, width, height }`, in pixels.
+        </ResponseField>
+      </Expandable>
+    </ResponseField>
+    <ResponseField name="annotatedImageUrl" type="string | null">
+      A URL of the screenshot with every detected element outlined.
+    </ResponseField>
+    <ResponseField name="imageWidth" type="number">
+      The width of the analyzed screenshot, in pixels.
+    </ResponseField>
+    <ResponseField name="imageHeight" type="number">
+      The height of the analyzed screenshot, in pixels.
+    </ResponseField>
+  </Expandable>
+</ResponseField>
+
+<Warning>
+  `interactivity` is a boolean, although the TypeScript types in `sdk.d.ts` declare it as a string. Compare it with `true`, not with a string like `'clickable'`.
+</Warning>
+
+## Errors
+
+`parse()` throws if the screen analysis fails. The error message comes from the TestDriver API.
 
 ## Examples
 
-### Get All Elements on Screen
+### List what's on screen
 
 ```javascript
-const result = await testdriver.parse();
-console.log(`Found ${result.elements.length} elements`);
+const { elements } = await testdriver.parse();
 
-result.elements.forEach((el, i) => {
-  console.log(`${i + 1}. [${el.type}] "${el.content}" (${el.interactivity})`);
-});
+for (const element of elements) {
+  console.log(`[${element.type}] "${element.content}" clickable=${element.interactivity}`);
+}
 ```
 
-### Find Clickable Elements
+### Find the clickable elements
 
 ```javascript
-const result = await testdriver.parse();
-
-const clickable = result.elements.filter(e => e.interactivity === 'clickable');
-console.log(`Found ${clickable.length} clickable elements`);
-
-clickable.forEach(el => {
-  console.log(`- "${el.content}" at (${el.bbox.x0}, ${el.bbox.y0})`);
-});
+const { elements } = await testdriver.parse();
+const clickable = elements.filter((element) => element.interactivity);
 ```
 
-### Find and Click an Element by Content
+### Click an element by its text
 
 ```javascript
-const result = await testdriver.parse();
-
-// Find a "Submit" button
-const submitBtn = result.elements.find(e => 
-  e.content.toLowerCase().includes('submit') && e.interactivity === 'clickable'
-);
-
-if (submitBtn) {
-  // Calculate center of the bounding box
-  const x = Math.round((submitBtn.bbox.x0 + submitBtn.bbox.x1) / 2);
-  const y = Math.round((submitBtn.bbox.y0 + submitBtn.bbox.y1) / 2);
-  
+const { elements } = await testdriver.parse();
+const signIn = elements.find((element) => element.content.includes('Sign in'));
+
+if (signIn) {
+  const x = Math.round((signIn.bbox.x0 + signIn.bbox.x1) / 2);
+  const y = Math.round((signIn.bbox.y0 + signIn.bbox.y1) / 2);
   await testdriver.click({ x, y });
 }
 ```
 
-### Filter by Element Type
-
-```javascript
-const result = await testdriver.parse();
-
-// Get all text elements
-const textElements = result.elements.filter(e => e.type === 'text');
-textElements.forEach(e => console.log(`Text: "${e.content}"`));
+Clicking by coordinates breaks when the layout changes. Prefer `find()` for clicks.
 
-// Get all icons
-const icons = result.elements.filter(e => e.type === 'icon');
-console.log(`Found ${icons.length} icons`);
+### See what was detected
 
-// Get all buttons
-const buttons = result.elements.filter(e => e.type === 'button');
-console.log(`Found ${buttons.length} buttons`);
+```javascript
+const { annotatedImageUrl } = await testdriver.parse();
+console.log(annotatedImageUrl);
 ```
 
-### Build Custom Assertions
+## Complete example
 
-```javascript
-import { describe, expect, it } from "vitest";
-import { TestDriver } from "testdriverai/vitest/hooks";
+```javascript tests/login-form.test.mjs
+import { describe, expect, it } from 'vitest';
+import { TestDriver } from 'testdriverai/vitest/hooks';
 
-describe("Login Page", () => {
-  it("should have expected form elements", async (context) => {
+describe('Login page', () => {
+  it('shows the username and password fields', async (context) => {
     const testdriver = TestDriver(context);
-    
-    await testdriver.provision.chrome({
-      url: 'https://myapp.com/login',
-    });
-
-    const result = await testdriver.parse();
-    
-    // Assert expected elements exist
-    const textContent = result.elements.map(e => e.content.toLowerCase());
-    expect(textContent).toContain('email');
-    expect(textContent).toContain('password');
-    
-    // Assert there are clickable elements
-    const clickable = result.elements.filter(e => e.interactivity === 'clickable');
-    expect(clickable.length).toBeGreaterThan(0);
-  });
-});
-```
+    await testdriver.provision.chrome({ url: 'https://testdriver-sandbox.vercel.app/login' });
 
-### Use Bounding Box Coordinates
+    const { elements } = await testdriver.parse();
+    const text = elements.map((element) => element.content.toLowerCase()).join(' ');
 
-```javascript
-const result = await testdriver.parse();
-
-result.elements.forEach(el => {
-  // Pixel coordinates
-  console.log(`Element "${el.content}":`);
-  console.log(`  bbox: (${el.bbox.x0}, ${el.bbox.y0}) to (${el.bbox.x1}, ${el.bbox.y1})`);
-  console.log(`  size: ${el.boundingBox.width}x${el.boundingBox.height}`);
-  console.log(`  position: left=${el.boundingBox.left}, top=${el.boundingBox.top}`);
+    expect(text).toContain('username');
+    expect(text).toContain('password');
+    expect(elements.some((element) => element.interactivity)).toBe(true);
+  });
 });
 ```
 
-### View Annotated Screenshot
-
-```javascript
-const result = await testdriver.parse();
-
-// The annotated image shows all detected elements with bounding boxes
-console.log('Annotated screenshot:', result.annotatedImageUrl);
-console.log(`Image dimensions: ${result.imageWidth}x${result.imageHeight}`);
-```
-
-## How It Works
-
-1. TestDriver captures a screenshot of the current screen
-2. The image is sent to the TestDriver API
-3. OmniParser v2 analyzes the image to detect all UI elements
-4. Each element is classified by type (text, icon, button, etc.) and interactivity
-5. Bounding box coordinates are returned in pixel coordinates matching the screen resolution
-
-<Note>
-  OmniParser detects elements visually — it works with any UI framework, native apps, and even non-standard interfaces. It does not rely on DOM or accessibility trees.
-</Note>
-
-## Best Practices
-
-<AccordionGroup>
-  <Accordion title="Use find() for targeting specific elements">
-    For locating and interacting with a specific element, prefer `find()` which uses AI vision. Use `parse()` when you need a complete inventory of all elements on screen.
-    
-    ```javascript
-    // Prefer this for clicking a specific element
-    await testdriver.find("Submit button").click();
-    
-    // Use parse() for full UI analysis
-    const result = await testdriver.parse();
-    const allButtons = result.elements.filter(e => e.type === 'button');
-    ```
-  </Accordion>
-  
-  <Accordion title="Filter by interactivity">
-    Use the `interactivity` field to distinguish between clickable and non-interactive elements.
-    
-    ```javascript
-    const result = await testdriver.parse();
-    const interactive = result.elements.filter(e => e.interactivity === 'clickable');
-    const static_ = result.elements.filter(e => e.interactivity === 'non-interactive');
-    ```
-  </Accordion>
-
-  <Accordion title="Wait for content to load">
-    If elements aren't being detected, the page may not be fully loaded. Add a wait first.
-    
-    ```javascript
-    // Wait for page to stabilize
-    await testdriver.wait(2000);
-    
-    // Then parse
-    const result = await testdriver.parse();
-    ```
-  </Accordion>
-  
-  <Accordion title="Use the annotated image for debugging">
-    The `annotatedImageUrl` provides a visual overlay showing all detected elements with their bounding boxes — great for debugging.
-    
-    ```javascript
-    const result = await testdriver.parse();
-    console.log('View annotated screenshot:', result.annotatedImageUrl);
-    ```
-  </Accordion>
-</AccordionGroup>
+See the [parse example](/examples/parse) for another complete test.
 
 ## Related
 
-- [find()](/find) - AI-powered element location
-- [assert()](/assert) - Make AI-powered assertions about screen state
-- [screenshot()](/screenshot) - Capture screenshots
-- [Elements Reference](/elements) - Complete Element API
+- [find()](/find): locate one element and act on it
+- [extract()](/extract): read one value off the screen
+- [click()](/click): click a point by its coordinates