@geometra/mcp 1.19.10 → 1.19.12

package/README.md

@@ -19,12 +19,13 @@ Geometra proxy:       Chromium → DOM geometry → same WebSocket as native →
 | Tool | Description |
 |---|---|
 | `geometra_connect` | Connect with `url` (ws://…) **or** `pageUrl` (https://…) to auto-start geometra-proxy; `url: "https://…"` is auto-coerced onto the proxy path |
-| `geometra_query` | Find elements by stable id, role, name, text content, current value, or semantic state such as `invalid`, `required`, or `busy` |
+| `geometra_query` | Find elements by stable id, role, name, text content, ancestor/prompt context, current value, or semantic state such as `invalid`, `required`, or `busy` |
 | `geometra_wait_for` | Wait for a semantic condition instead of guessing sleeps (`busy`, `disabled`, alerts, values, etc.) |
-| `geometra_fill_fields` | Fill labeled text/choice/toggle/file fields in one MCP call |
-| `geometra_run_actions` | Execute a batch of high-level actions in one MCP round trip and get one consolidated result |
+| `geometra_fill_fields` | Fill labeled text/choice/toggle/file fields in one MCP call; can return final-only status for the smallest responses |
+| `geometra_run_actions` | Execute a batch of high-level actions in one MCP round trip and get one consolidated result, with optional final-only output |
 | `geometra_page_model` | Summary-first webpage model: archetypes, stable section ids, counts, top-level sections, primary actions |
-| `geometra_expand_section` | Expand one form/dialog/list/landmark from `geometra_page_model` on demand |
+| `geometra_expand_section` | Expand one form/dialog/list/landmark from `geometra_page_model` on demand, with paging/filtering for long sections |
+| `geometra_reveal` | Scroll until a matching node is visible instead of guessing wheel deltas |
 | `geometra_click` | Click an element by coordinates |
 | `geometra_type` | Type text into the focused element |
 | `geometra_key` | Send special keys (Enter, Tab, Escape, arrows) |
@@ -39,27 +40,155 @@ Geometra proxy:       Chromium → DOM geometry → same WebSocket as native →
 
 ## Setup
 
-### Claude Code
+<details>
+<summary>Claude Code</summary>
 
+**One-line install:**
 ```bash
-claude mcp add geometra -- npx @geometra/mcp
+claude mcp add geometra -- npx -y @geometra/mcp
 ```
 
-### Claude Desktop
+**Uninstall:**
+```bash
+claude mcp remove geometra
+```
+
+Or manually add to `.mcp.json` (project-level) or `~/.claude/settings.json` (global):
+```json
+{
+  "mcpServers": {
+    "geometra": {
+      "command": "npx",
+      "args": ["-y", "@geometra/mcp"]
+    }
+  }
+}
+```
+
+To uninstall manually, remove the `geometra` entry from the config file.
+
+</details>
+
+<details>
+<summary>Claude Desktop</summary>
+
+Add to your Claude Desktop MCP config:
+
+```json
+{
+  "mcpServers": {
+    "geometra": {
+      "command": "npx",
+      "args": ["-y", "@geometra/mcp"]
+    }
+  }
+}
+```
+
+To uninstall, remove the `geometra` entry from the config file.
+
+</details>
+
+<details>
+<summary>OpenAI Codex</summary>
+
+Add to your Codex MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "geometra": {
+      "command": "npx",
+      "args": ["-y", "@geometra/mcp"]
+    }
+  }
+}
+```
+
+To uninstall, remove the `geometra` entry from the config file.
+
+</details>
 
-Add to `claude_desktop_config.json`:
+<details>
+<summary>Cursor</summary>
+
+Open Settings → MCP → Add new MCP server, or add to `.cursor/mcp.json`:
 
 ```json
 {
   "mcpServers": {
     "geometra": {
       "command": "npx",
-      "args": ["@geometra/mcp"]
+      "args": ["-y", "@geometra/mcp"]
     }
   }
 }
 ```
 
+To uninstall, remove the entry from MCP settings.
+
+</details>
+
+<details>
+<summary>Windsurf</summary>
+
+Add to `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "geometra": {
+      "command": "npx",
+      "args": ["-y", "@geometra/mcp"]
+    }
+  }
+}
+```
+
+To uninstall, remove the entry from the config file.
+
+</details>
+
+<details>
+<summary>VS Code / Copilot</summary>
+
+**One-line install:**
+```bash
+code --add-mcp '{"name":"geometra","command":"npx","args":["-y","@geometra/mcp"]}'
+```
+
+Or add to `.vscode/mcp.json`:
+```json
+{
+  "servers": {
+    "geometra": {
+      "command": "npx",
+      "args": ["-y", "@geometra/mcp"]
+    }
+  }
+}
+```
+
+To uninstall, remove the entry from MCP settings or delete the server from the MCP panel.
+
+</details>
+
+<details>
+<summary>Other MCP clients</summary>
+
+Any MCP client that supports stdio transport can use Geometra. The server config is:
+
+```json
+{
+  "command": "npx",
+  "args": ["-y", "@geometra/mcp"]
+}
+```
+
+To uninstall, remove the server entry from your client's MCP configuration.
+
+</details>
+
 ### From source (this repo)
 
 ```bash
@@ -182,8 +311,9 @@ For long application flows, prefer one of these patterns:
 
 1. `geometra_page_model`
 2. `geometra_expand_section`
-3. `geometra_fill_fields` for obvious field entry
-4. `geometra_run_actions` when you need mixed navigation + waits + field entry
+3. `geometra_reveal` for far-below-fold targets such as submit buttons
+4. `geometra_fill_fields` for obvious field entry
+5. `geometra_run_actions` when you need mixed navigation + waits + field entry
 
 Typical batch:
 
@@ -200,6 +330,18 @@ Typical batch:
 
 Single action tools now default to terse summaries. Pass `detail: "verbose"` when you need a fuller current-UI fallback for debugging.
 
+For the smallest long-form responses, prefer:
+
+1. `detail: "minimal"` for structured step metadata instead of narrated deltas
+2. `includeSteps: false` when you only need aggregate success/error counts plus the final validation/state payload
+
+For long single-page forms:
+
+1. Use `geometra_expand_section` with `fieldOffset` / `actionOffset` to page through large forms instead of taking a full snapshot.
+2. Add `onlyRequiredFields: true` or `onlyInvalidFields: true` when you want the actionable subset.
+3. Use `contextText` in `geometra_query` / `geometra_wait_for` to disambiguate repeated `Yes` / `No` controls by question text.
+4. Use `geometra_reveal` instead of manual wheel loops when the next target is offscreen.
+
 Typical field fill:
 
 ```json
@@ -211,7 +353,9 @@ Typical field fill:
     { "kind": "choice", "fieldLabel": "Will you require sponsorship?", "value": "No" },
     { "kind": "file", "fieldLabel": "Resume", "paths": ["/Users/you/resume.pdf"] }
   ],
-  "failOnInvalid": true
+  "failOnInvalid": true,
+  "detail": "minimal",
+  "includeSteps": false
 }
 ```
 

package/dist/__tests__/server-batch-results.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/server-batch-results.test.js

@@ -0,0 +1,311 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+function node(role, name, options) {
+    return {
+        role,
+        ...(name ? { name } : {}),
+        ...(options?.value ? { value: options.value } : {}),
+        ...(options?.state ? { state: options.state } : {}),
+        ...(options?.validation ? { validation: options.validation } : {}),
+        ...(options?.meta ? { meta: options.meta } : {}),
+        bounds: options?.bounds ?? { x: 0, y: 0, width: 120, height: 40 },
+        path: options?.path ?? [],
+        children: options?.children ?? [],
+        focusable: role !== 'group',
+    };
+}
+const mockState = vi.hoisted(() => ({
+    currentA11yRoot: node('group', undefined, {
+        meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 0 },
+    }),
+    session: {
+        tree: { kind: 'box' },
+        layout: { x: 0, y: 0, width: 1280, height: 800, children: [] },
+        url: 'ws://127.0.0.1:3200',
+        updateRevision: 1,
+    },
+    sendClick: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendType: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendKey: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendFileUpload: vi.fn(async () => ({ status: 'updated', timeoutMs: 8000 })),
+    sendFieldText: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendFieldChoice: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendListboxPick: vi.fn(async () => ({ status: 'updated', timeoutMs: 4500 })),
+    sendSelectOption: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendSetChecked: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    sendWheel: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
+    waitForUiCondition: vi.fn(async () => true),
+}));
+vi.mock('../session.js', () => ({
+    connect: vi.fn(),
+    connectThroughProxy: vi.fn(),
+    disconnect: vi.fn(),
+    getSession: vi.fn(() => mockState.session),
+    sendClick: mockState.sendClick,
+    sendType: mockState.sendType,
+    sendKey: mockState.sendKey,
+    sendFileUpload: mockState.sendFileUpload,
+    sendFieldText: mockState.sendFieldText,
+    sendFieldChoice: mockState.sendFieldChoice,
+    sendListboxPick: mockState.sendListboxPick,
+    sendSelectOption: mockState.sendSelectOption,
+    sendSetChecked: mockState.sendSetChecked,
+    sendWheel: mockState.sendWheel,
+    buildA11yTree: vi.fn(() => mockState.currentA11yRoot),
+    buildCompactUiIndex: vi.fn(() => ({ nodes: [], context: {} })),
+    buildPageModel: vi.fn(() => ({
+        viewport: { width: 1280, height: 800 },
+        archetypes: ['form'],
+        summary: { landmarkCount: 0, formCount: 1, dialogCount: 0, listCount: 0, focusableCount: 2 },
+        primaryActions: [],
+        landmarks: [],
+        forms: [],
+        dialogs: [],
+        lists: [],
+    })),
+    expandPageSection: vi.fn(() => null),
+    buildUiDelta: vi.fn(() => ({})),
+    hasUiDelta: vi.fn(() => false),
+    nodeIdForPath: vi.fn((path) => `n:${path.length > 0 ? path.join('.') : 'root'}`),
+    summarizeCompactIndex: vi.fn(() => ''),
+    summarizePageModel: vi.fn(() => ''),
+    summarizeUiDelta: vi.fn(() => ''),
+    waitForUiCondition: mockState.waitForUiCondition,
+}));
+const { createServer } = await import('../server.js');
+function getToolHandler(name) {
+    const server = createServer();
+    return server._registeredTools[name].handler;
+}
+describe('batch MCP result shaping', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 420 },
+            children: [
+                node('textbox', 'Mission', {
+                    value: 'Ship calm developer tools across browsers and platforms.',
+                    path: [0],
+                }),
+                node('textbox', 'Email', {
+                    value: 'taylor@example.com',
+                    path: [1],
+                }),
+            ],
+        });
+    });
+    it('keeps fill_fields minimal output structured and does not echo long essay text', async () => {
+        const longAnswer = 'A'.repeat(180);
+        const handler = getToolHandler('geometra_fill_fields');
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 420 },
+            children: [
+                node('textbox', 'Mission', { value: longAnswer, path: [0] }),
+                node('textbox', 'Email', { value: 'taylor@example.com', path: [1] }),
+            ],
+        });
+        const result = await handler({
+            fields: [
+                { kind: 'text', fieldLabel: 'Mission', value: longAnswer },
+                { kind: 'text', fieldLabel: 'Email', value: 'taylor@example.com' },
+            ],
+            stopOnError: true,
+            failOnInvalid: false,
+            includeSteps: true,
+            detail: 'minimal',
+        });
+        const text = result.content[0].text;
+        const payload = JSON.parse(text);
+        const steps = payload.steps;
+        expect(text).not.toContain(longAnswer);
+        expect(payload).toMatchObject({
+            completed: true,
+            fieldCount: 2,
+            successCount: 2,
+            errorCount: 0,
+        });
+        expect(steps[0]).toMatchObject({
+            index: 0,
+            kind: 'text',
+            ok: true,
+            fieldLabel: 'Mission',
+            valueLength: 180,
+            wait: 'updated',
+            readback: { role: 'textbox', valueLength: 180 },
+        });
+        expect(steps[1]).toMatchObject({
+            index: 1,
+            kind: 'text',
+            ok: true,
+            fieldLabel: 'Email',
+            value: 'taylor@example.com',
+            wait: 'updated',
+            readback: { role: 'textbox', value: 'taylor@example.com' },
+        });
+    });
+    it('lets run_actions omit step listings while keeping capped final validation state', async () => {
+        const handler = getToolHandler('geometra_run_actions');
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 2400 },
+            children: [
+                node('textbox', 'Full name', {
+                    value: '',
+                    path: [0],
+                    state: { invalid: true, required: true },
+                    validation: { error: 'Enter your full name.' },
+                }),
+                node('textbox', 'Email', {
+                    value: '',
+                    path: [1],
+                    state: { invalid: true, required: true },
+                    validation: { error: 'Enter your email.' },
+                }),
+                node('textbox', 'Phone', {
+                    value: '',
+                    path: [2],
+                    state: { invalid: true, required: true },
+                    validation: { error: 'Enter your phone number.' },
+                }),
+                node('textbox', 'Location', {
+                    value: '',
+                    path: [3],
+                    state: { invalid: true, required: true },
+                    validation: { error: 'Choose a location.' },
+                }),
+                node('textbox', 'LinkedIn', {
+                    value: '',
+                    path: [4],
+                    state: { invalid: true },
+                    validation: { error: 'Enter a valid URL.' },
+                }),
+                node('alert', 'Your form needs corrections', { path: [5] }),
+            ],
+        });
+        const result = await handler({
+            actions: [{ type: 'click', x: 320, y: 540 }],
+            stopOnError: true,
+            includeSteps: false,
+            detail: 'minimal',
+        });
+        const payload = JSON.parse(result.content[0].text);
+        const final = payload.final;
+        expect(payload).toMatchObject({
+            completed: true,
+            stepCount: 1,
+            successCount: 1,
+            errorCount: 0,
+        });
+        expect(payload).not.toHaveProperty('steps');
+        expect(final).toMatchObject({
+            pageUrl: 'https://jobs.example.com/application',
+            alertCount: 1,
+            invalidCount: 5,
+        });
+        expect(final.invalidFields.length).toBe(4);
+        expect(final.alerts.length).toBe(1);
+    });
+});
+describe('query and reveal tools', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('lets query disambiguate repeated controls by context text', async () => {
+        const handler = getToolHandler('geometra_query');
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 900 },
+            children: [
+                node('form', 'Application', {
+                    path: [0],
+                    children: [
+                        node('group', undefined, {
+                            path: [0, 0],
+                            children: [
+                                node('text', 'Are you legally authorized to work here?', { path: [0, 0, 0] }),
+                                node('button', 'Yes', { path: [0, 0, 1] }),
+                                node('button', 'No', { path: [0, 0, 2] }),
+                            ],
+                        }),
+                        node('group', undefined, {
+                            path: [0, 1],
+                            children: [
+                                node('text', 'Will you require sponsorship?', { path: [0, 1, 0] }),
+                                node('button', 'Yes', { path: [0, 1, 1] }),
+                                node('button', 'No', { path: [0, 1, 2] }),
+                            ],
+                        }),
+                    ],
+                }),
+            ],
+        });
+        const result = await handler({
+            role: 'button',
+            name: 'Yes',
+            contextText: 'sponsorship',
+        });
+        const payload = JSON.parse(result.content[0].text);
+        expect(payload).toHaveLength(1);
+        expect(payload[0]).toMatchObject({
+            role: 'button',
+            name: 'Yes',
+            context: {
+                prompt: 'Will you require sponsorship?',
+                section: 'Application',
+            },
+        });
+    });
+    it('reveals an offscreen target with semantic scrolling instead of requiring manual wheels', async () => {
+        const handler = getToolHandler('geometra_reveal');
+        mockState.currentA11yRoot = node('group', undefined, {
+            bounds: { x: 0, y: 0, width: 1280, height: 800 },
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 0 },
+            children: [
+                node('form', 'Application', {
+                    bounds: { x: 20, y: -200, width: 760, height: 1900 },
+                    path: [0],
+                    children: [
+                        node('button', 'Submit application', {
+                            bounds: { x: 60, y: 1540, width: 180, height: 40 },
+                            path: [0, 0],
+                        }),
+                    ],
+                }),
+            ],
+        });
+        mockState.sendWheel.mockImplementationOnce(async () => {
+            mockState.currentA11yRoot = node('group', undefined, {
+                bounds: { x: 0, y: 0, width: 1280, height: 800 },
+                meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 1220 },
+                children: [
+                    node('form', 'Application', {
+                        bounds: { x: 20, y: -1420, width: 760, height: 1900 },
+                        path: [0],
+                        children: [
+                            node('button', 'Submit application', {
+                                bounds: { x: 60, y: 320, width: 180, height: 40 },
+                                path: [0, 0],
+                            }),
+                        ],
+                    }),
+                ],
+            });
+            return { status: 'updated', timeoutMs: 2500 };
+        });
+        const result = await handler({
+            role: 'button',
+            name: 'Submit application',
+            maxSteps: 3,
+            fullyVisible: true,
+            timeoutMs: 2500,
+        });
+        const payload = JSON.parse(result.content[0].text);
+        expect(mockState.sendWheel).toHaveBeenCalledWith(mockState.session, expect.any(Number), expect.objectContaining({ x: expect.any(Number), y: expect.any(Number) }), 2500);
+        expect(payload).toMatchObject({
+            revealed: true,
+            attempts: 1,
+            target: {
+                role: 'button',
+                name: 'Submit application',
+                visibility: { fullyVisible: true },
+            },
+        });
+    });
+});

package/dist/__tests__/session-model.test.js

@@ -115,17 +115,117 @@ describe('buildPageModel', () => {
             summary: {
                 headingCount: 1,
                 fieldCount: 2,
+                requiredFieldCount: 2,
+                invalidFieldCount: 1,
                 actionCount: 1,
             },
+            page: {
+                fields: { offset: 0, returned: 2, total: 2, hasMore: false },
+                actions: { offset: 0, returned: 1, total: 1, hasMore: false },
+            },
         });
         expect(detail?.fields.map(field => field.name)).toEqual(['Full name', 'Email']);
         expect(detail?.fields.map(field => field.value)).toEqual(['Taylor Applicant', 'taylor@example.com']);
         expect(detail?.fields[0]?.state).toEqual({ required: true });
         expect(detail?.fields[1]?.state).toEqual({ invalid: true, required: true });
         expect(detail?.fields[1]?.validation).toEqual({ error: 'Please enter a valid email address.' });
+        expect(detail?.fields[1]?.visibility).toMatchObject({ intersectsViewport: true, fullyVisible: true });
+        expect(detail?.actions[0]?.scrollHint).toMatchObject({ status: 'visible' });
         expect(detail?.actions.map(action => action.id)).toEqual(['n:0.0.3']);
         expect(detail?.fields[0]).not.toHaveProperty('bounds');
     });
+    it('paginates long sections and carries context on repeated answers', () => {
+        const tree = node('group', undefined, { x: 0, y: 0, width: 900, height: 700 }, {
+            children: [
+                node('form', 'Application', { x: 20, y: -120, width: 760, height: 1800 }, {
+                    path: [0],
+                    children: [
+                        node('heading', 'Application', { x: 40, y: 40, width: 240, height: 28 }, { path: [0, 0] }),
+                        node('textbox', 'Full name', { x: 48, y: 120, width: 320, height: 36 }, {
+                            path: [0, 1],
+                            state: { required: true },
+                        }),
+                        node('textbox', 'Email', { x: 48, y: 176, width: 320, height: 36 }, {
+                            path: [0, 2],
+                            state: { required: true, invalid: true },
+                            validation: { error: 'Enter a valid email.' },
+                        }),
+                        node('textbox', 'Phone', { x: 48, y: 232, width: 320, height: 36 }, {
+                            path: [0, 3],
+                            state: { required: true },
+                        }),
+                        node('group', undefined, { x: 40, y: 980, width: 520, height: 96 }, {
+                            path: [0, 4],
+                            children: [
+                                node('text', 'Are you legally authorized to work here?', { x: 48, y: 980, width: 340, height: 24 }, {
+                                    path: [0, 4, 0],
+                                }),
+                                node('button', 'Yes', { x: 48, y: 1020, width: 88, height: 40 }, {
+                                    path: [0, 4, 1],
+                                    focusable: true,
+                                }),
+                                node('button', 'No', { x: 148, y: 1020, width: 88, height: 40 }, {
+                                    path: [0, 4, 2],
+                                    focusable: true,
+                                }),
+                            ],
+                        }),
+                        node('group', undefined, { x: 40, y: 1120, width: 520, height: 96 }, {
+                            path: [0, 5],
+                            children: [
+                                node('text', 'Will you require sponsorship?', { x: 48, y: 1120, width: 260, height: 24 }, {
+                                    path: [0, 5, 0],
+                                }),
+                                node('button', 'Yes', { x: 48, y: 1160, width: 88, height: 40 }, {
+                                    path: [0, 5, 1],
+                                    focusable: true,
+                                }),
+                                node('button', 'No', { x: 148, y: 1160, width: 88, height: 40 }, {
+                                    path: [0, 5, 2],
+                                    focusable: true,
+                                }),
+                            ],
+                        }),
+                        node('button', 'Submit application', { x: 48, y: 1540, width: 180, height: 40 }, {
+                            path: [0, 6],
+                            focusable: true,
+                        }),
+                    ],
+                }),
+            ],
+        });
+        const detail = expandPageSection(tree, 'fm:0', {
+            maxFields: 2,
+            fieldOffset: 1,
+            onlyRequiredFields: true,
+        });
+        expect(detail).toMatchObject({
+            summary: {
+                fieldCount: 3,
+                requiredFieldCount: 3,
+                invalidFieldCount: 1,
+                actionCount: 5,
+            },
+            page: {
+                fields: { offset: 1, returned: 2, total: 3, hasMore: false },
+                actions: { offset: 0, returned: 5, total: 5, hasMore: false },
+            },
+        });
+        expect(detail?.fields.map(field => field.name)).toEqual(['Email', 'Phone']);
+        expect(detail?.fields[0]?.scrollHint).toMatchObject({ status: 'visible' });
+        const authorizedYes = detail?.actions.find(action => action.name === 'Yes' && action.context?.prompt === 'Are you legally authorized to work here?');
+        const sponsorshipYes = detail?.actions.find(action => action.name === 'Yes' && action.context?.prompt === 'Will you require sponsorship?');
+        expect(authorizedYes).toMatchObject({
+            name: 'Yes',
+            context: { prompt: 'Are you legally authorized to work here?', section: 'Application' },
+            visibility: { fullyVisible: false, offscreenBelow: true },
+        });
+        expect(sponsorshipYes).toMatchObject({
+            name: 'Yes',
+            context: { prompt: 'Will you require sponsorship?', section: 'Application' },
+            visibility: { fullyVisible: false, offscreenBelow: true },
+        });
+    });
     it('drops noisy container names and falls back to unnamed summaries', () => {
         const tree = node('group', undefined, { x: 0, y: 0, width: 800, height: 600 }, {
             children: [

package/dist/server.d.ts

@@ -6,6 +6,7 @@ interface NodeFilter {
     role?: string;
     name?: string;
     text?: string;
+    contextText?: string;
     value?: string;
     checked?: NodeStateFilterValue;
     disabled?: boolean;