@geometra/mcp 1.19.12 → 1.19.14

package/README.md

@@ -21,6 +21,8 @@ Geometra proxy:       Chromium → DOM geometry → same WebSocket as native →
 | `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, 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_form_schema` | Compact, fill-oriented form schema with stable field ids and collapsed radio/button groups |
+| `geometra_fill_form` | Fill a form from `valuesById` / `valuesByLabel` in one MCP call; preferred low-token happy path for standard forms |
 | `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 |
@@ -275,19 +277,15 @@ With `python3 -m http.server 8080` in `demos/proxy-mcp-sample` and `npx geometra
 Agent:  geometra_connect({ url: "ws://127.0.0.1:3200" })
         → Connected. UI includes textbox "Email", button "Save", …
 
-Agent:  geometra_page_model({})
-        → {"viewport":{"width":1024,"height":768},"archetypes":["shell","form"],"summary":{...},"forms":[{"id":"fm:1.0","fieldCount":3,"actionCount":1}], ...}
+Agent:  geometra_form_schema({})
+        → {"forms":[{"formId":"fm:1.0","fields":[{"id":"ff:1.0.0","label":"Email"}, ...]}]}
 
-Agent:  geometra_expand_section({ id: "fm:1.0" })
-        → {"id":"fm:1.0","kind":"form","fields":[{"id":"n:1.0.0","name":"Email"}, ...], "actions":[...]}
-
-Agent:  geometra_query({ role: "textbox", name: "Email" })
-        → bounds for the email field (viewport coordinates)
-
-Agent:  geometra_click({ x: <center-x>, y: <center-y> })
-        → Focuses the input
-
-Agent:  geometra_type({ text: "hello@example.com" })
+Agent:  geometra_fill_form({
+          formId: "fm:1.0",
+          valuesByLabel: { "Email": "hello@example.com" },
+          failOnInvalid: true
+        })
+        → {"completed":true,"successCount":1,"errorCount":0,"final":{"invalidCount":0,...}}
 
 Agent:  geometra_query({ role: "button", name: "Save" })
         → Click center to submit the sample form; status text updates in the DOM
@@ -299,21 +297,22 @@ Agent:  geometra_query({ role: "button", name: "Save" })
 2. It receives the computed layout (`{ x, y, width, height }` for every node) and the UI tree (`kind`, `semantic`, `props`, `handlers`, `children`).
 3. It builds an accessibility tree from that data — roles, names, focusable state, bounds.
 4. **`geometra_snapshot`** defaults to a **compact** flat list of viewport-visible actionable nodes (minified JSON) to reduce LLM tokens; use `view: "full"` for the complete nested tree.
-5. **`geometra_page_model`** is summary-first: page archetypes, stable section ids, counts, top-level landmarks/forms/dialogs/lists, and a few primary actions. It is designed to be cheaper than dumping full previews for every section.
-6. **`geometra_expand_section`** fetches richer details only for the section you care about (fields, actions, headings, nested lists, list items, text preview).
-7. After interactions, action tools return a **semantic delta** when possible (dialogs opened/closed, forms appeared/removed, list counts changed, named/focusable nodes added/removed/updated). If nothing meaningful changed, they fall back to a short current-UI overview.
-8. Tools expose query, click, type, snapshot, page-model, and section-expansion operations over this structured data.
-9. After each interaction, the peer sends updated geometry (full `frame` or `patch`) — the MCP tools interpret that into compact summaries.
+5. **`geometra_form_schema`** is the compact form-specific path: stable field ids, required/invalid state, current values, and collapsed choice groups without layout-heavy section detail.
+6. **`geometra_fill_form`** turns a compact values object into semantic field operations server-side, so the model does not need to emit one tool call per field.
+7. **`geometra_page_model`** is still the right summary-first path for non-form exploration: page archetypes, stable section ids, counts, top-level landmarks/forms/dialogs/lists, and a few primary actions.
+8. **`geometra_expand_section`** fetches richer details only for the section you care about (fields, actions, headings, nested lists, list items, text preview).
+9. After interactions, action tools return a **semantic delta** when possible (dialogs opened/closed, forms appeared/removed, list counts changed, named/focusable nodes added/removed/updated). If nothing meaningful changed, they fall back to a short current-UI overview.
+10. After each interaction, the peer sends updated geometry (full `frame` or `patch`) — the MCP tools interpret that into compact summaries.
 
 ## Long Forms
 
 For long application flows, prefer one of these patterns:
 
-1. `geometra_page_model`
-2. `geometra_expand_section`
+1. `geometra_form_schema`
+2. `geometra_fill_form`
 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
+4. `geometra_run_actions` when you need mixed navigation + waits + field entry
+5. `geometra_page_model` + `geometra_expand_section` when you are still exploring the page rather than filling it
 
 Typical batch:
 
@@ -335,6 +334,23 @@ 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
 
+Typical low-token form fill:
+
+```json
+{
+  "formId": "fm:1.0",
+  "valuesById": {
+    "ff:1.0.0": "Taylor Applicant",
+    "ff:1.0.1": "taylor@example.com",
+    "ff:1.0.2": "Germany",
+    "ff:1.0.3": "No"
+  },
+  "failOnInvalid": true,
+  "includeSteps": false,
+  "detail": "minimal"
+}
+```
+
 For long single-page forms:
 
 1. Use `geometra_expand_section` with `fieldOffset` / `actionOffset` to page through large forms instead of taking a full snapshot.

package/dist/__tests__/connect-utils.test.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
@@ -78,7 +78,22 @@ describe('proxy ready helpers', () => {
             const packageDir = path.join(scopeDir, 'proxy');
             const probePath = path.join(tempRoot, 'probe.cjs');
             mkdirSync(scopeDir, { recursive: true });
-            symlinkSync(path.resolve(process.cwd(), 'packages/proxy'), packageDir, 'dir');
+            mkdirSync(path.join(packageDir, 'src'), { recursive: true });
+            writeFileSync(path.join(packageDir, 'package.json'), JSON.stringify({
+                name: '@geometra/proxy',
+                version: '0.0.0-test',
+                type: 'module',
+            }));
+            writeFileSync(path.join(packageDir, 'tsconfig.build.json'), JSON.stringify({
+                extends: path.resolve(process.cwd(), 'tsconfig.base.json'),
+                compilerOptions: {
+                    outDir: 'dist',
+                    rootDir: 'src',
+                    noEmit: false,
+                },
+                include: ['src'],
+            }));
+            writeFileSync(path.join(packageDir, 'src', 'index.ts'), 'console.log("proxy");\n');
             writeFileSync(probePath, 'module.exports = {}');
             const customRequire = createRequire(probePath);
             const scriptPath = resolveProxyScriptPathWith(customRequire);
@@ -89,6 +104,33 @@ describe('proxy ready helpers', () => {
             rmSync(tempRoot, { recursive: true, force: true });
         }
     });
+    it('prefers the current workspace proxy dist over a bundled nested dependency in source checkouts', () => {
+        const tempRoot = mkdtempSync(path.join(tmpdir(), 'geometra-proxy-workspace-prefer-'));
+        try {
+            const workspaceDistDir = path.join(tempRoot, 'packages', 'proxy', 'dist');
+            const bundledProxyDir = path.join(tempRoot, 'mcp', 'node_modules', '@geometra', 'proxy');
+            const bundledDistDir = path.join(bundledProxyDir, 'dist');
+            const mcpDistDir = path.join(tempRoot, 'mcp', 'dist');
+            const probePath = path.join(mcpDistDir, 'proxy-spawn.cjs');
+            mkdirSync(workspaceDistDir, { recursive: true });
+            mkdirSync(bundledDistDir, { recursive: true });
+            mkdirSync(mcpDistDir, { recursive: true });
+            writeFileSync(path.join(workspaceDistDir, 'index.js'), 'export const source = "workspace";\n');
+            writeFileSync(path.join(bundledDistDir, 'index.js'), 'export const source = "bundled";\n');
+            writeFileSync(path.join(bundledProxyDir, 'package.json'), JSON.stringify({
+                name: '@geometra/proxy',
+                version: '0.0.0-test',
+                type: 'module',
+            }));
+            writeFileSync(probePath, 'module.exports = {};\n');
+            const customRequire = createRequire(probePath);
+            const scriptPath = resolveProxyScriptPathWith(customRequire, mcpDistDir);
+            expect(scriptPath).toBe(path.join(workspaceDistDir, 'index.js'));
+        }
+        finally {
+            rmSync(tempRoot, { recursive: true, force: true });
+        }
+    });
     it('falls back to the packaged sibling proxy dist when package exports are stale', () => {
         const tempRoot = mkdtempSync(path.join(tmpdir(), 'geometra-proxy-stale-exports-'));
         try {

package/dist/__tests__/proxy-session-actions.test.js

@@ -1,6 +1,6 @@
 import { afterAll, describe, expect, it } from 'vitest';
 import { WebSocketServer } from 'ws';
-import { connect, disconnect, sendClick, sendListboxPick } from '../session.js';
+import { connect, disconnect, sendClick, sendFillFields, sendListboxPick } from '../session.js';
 describe('proxy-backed MCP actions', () => {
     afterAll(() => {
         disconnect();
@@ -97,6 +97,83 @@ describe('proxy-backed MCP actions', () => {
             await new Promise((resolve, reject) => wss.close(err => (err ? reject(err) : resolve())));
         }
     });
+    it('sends batched fillFields messages and resolves from the resulting update', async () => {
+        const wss = new WebSocketServer({ port: 0 });
+        let seenMessage;
+        wss.on('connection', ws => {
+            ws.on('message', raw => {
+                const msg = JSON.parse(String(raw));
+                if (msg.type === 'resize') {
+                    ws.send(JSON.stringify({
+                        type: 'frame',
+                        layout: { x: 0, y: 0, width: 1024, height: 768, children: [] },
+                        tree: { kind: 'box', props: {}, semantic: { tag: 'body', role: 'group' }, children: [] },
+                    }));
+                    return;
+                }
+                if (msg.type === 'fillFields') {
+                    seenMessage = msg;
+                    ws.send(JSON.stringify({
+                        type: 'ack',
+                        requestId: msg.requestId,
+                        result: {
+                            pageUrl: 'https://jobs.example.com/application',
+                            invalidCount: 0,
+                            alertCount: 0,
+                            dialogCount: 0,
+                            busyCount: 0,
+                        },
+                    }));
+                    ws.send(JSON.stringify({
+                        type: 'frame',
+                        layout: { x: 0, y: 0, width: 1024, height: 768, children: [] },
+                        tree: {
+                            kind: 'box',
+                            props: {},
+                            semantic: { tag: 'body', role: 'group', ariaLabel: 'Filled' },
+                            children: [],
+                        },
+                    }));
+                }
+            });
+        });
+        const port = await new Promise((resolve, reject) => {
+            wss.once('listening', () => {
+                const address = wss.address();
+                if (typeof address === 'object' && address)
+                    resolve(address.port);
+                else
+                    reject(new Error('Failed to resolve ephemeral WebSocket port'));
+            });
+            wss.once('error', reject);
+        });
+        try {
+            const session = await connect(`ws://127.0.0.1:${port}`);
+            await expect(sendFillFields(session, [
+                { kind: 'text', fieldLabel: 'Full name', value: 'Taylor Applicant' },
+                { kind: 'choice', fieldLabel: 'Country', value: 'Germany' },
+            ], 80)).resolves.toMatchObject({
+                status: 'acknowledged',
+                timeoutMs: 80,
+                result: {
+                    pageUrl: 'https://jobs.example.com/application',
+                    invalidCount: 0,
+                    alertCount: 0,
+                },
+            });
+            expect(seenMessage).toMatchObject({
+                type: 'fillFields',
+                fields: [
+                    { kind: 'text', fieldLabel: 'Full name', value: 'Taylor Applicant' },
+                    { kind: 'choice', fieldLabel: 'Country', value: 'Germany' },
+                ],
+            });
+        }
+        finally {
+            disconnect();
+            await new Promise((resolve, reject) => wss.close(err => (err ? reject(err) : resolve())));
+        }
+    });
     it('ignores invalid patch paths instead of mutating ancestor layout nodes', async () => {
         const wss = new WebSocketServer({ port: 0 });
         wss.on('connection', ws => {

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

@@ -23,12 +23,20 @@ const mockState = vi.hoisted(() => ({
         url: 'ws://127.0.0.1:3200',
         updateRevision: 1,
     },
+    formSchemas: [],
+    connect: vi.fn(),
+    connectThroughProxy: vi.fn(),
     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 })),
+    sendFillFields: vi.fn(async () => ({
+        status: 'updated',
+        timeoutMs: 6000,
+        result: undefined,
+    })),
     sendListboxPick: vi.fn(async () => ({ status: 'updated', timeoutMs: 4500 })),
     sendSelectOption: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
     sendSetChecked: vi.fn(async () => ({ status: 'updated', timeoutMs: 2000 })),
@@ -36,8 +44,8 @@ const mockState = vi.hoisted(() => ({
     waitForUiCondition: vi.fn(async () => true),
 }));
 vi.mock('../session.js', () => ({
-    connect: vi.fn(),
-    connectThroughProxy: vi.fn(),
+    connect: mockState.connect,
+    connectThroughProxy: mockState.connectThroughProxy,
     disconnect: vi.fn(),
     getSession: vi.fn(() => mockState.session),
     sendClick: mockState.sendClick,
@@ -46,6 +54,7 @@ vi.mock('../session.js', () => ({
     sendFileUpload: mockState.sendFileUpload,
     sendFieldText: mockState.sendFieldText,
     sendFieldChoice: mockState.sendFieldChoice,
+    sendFillFields: mockState.sendFillFields,
     sendListboxPick: mockState.sendListboxPick,
     sendSelectOption: mockState.sendSelectOption,
     sendSetChecked: mockState.sendSetChecked,
@@ -62,6 +71,7 @@ vi.mock('../session.js', () => ({
         dialogs: [],
         lists: [],
     })),
+    buildFormSchemas: vi.fn(() => mockState.formSchemas),
     expandPageSection: vi.fn(() => null),
     buildUiDelta: vi.fn(() => ({})),
     hasUiDelta: vi.fn(() => false),
@@ -79,6 +89,9 @@ function getToolHandler(name) {
 describe('batch MCP result shaping', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        mockState.connect.mockResolvedValue(mockState.session);
+        mockState.connectThroughProxy.mockResolvedValue(mockState.session);
+        mockState.formSchemas = [];
         mockState.currentA11yRoot = node('group', undefined, {
             meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 420 },
             children: [
@@ -203,6 +216,186 @@ describe('batch MCP result shaping', () => {
         expect(final.invalidFields.length).toBe(4);
         expect(final.alerts.length).toBe(1);
     });
+    it('returns a compact structured connect payload by default', async () => {
+        const handler = getToolHandler('geometra_connect');
+        const result = await handler({
+            pageUrl: 'https://jobs.example.com/application',
+            headless: true,
+        });
+        const payload = JSON.parse(result.content[0].text);
+        expect(payload).toMatchObject({
+            connected: true,
+            transport: 'proxy',
+            wsUrl: 'ws://127.0.0.1:3200',
+            pageUrl: 'https://jobs.example.com/application',
+        });
+        expect(payload).not.toHaveProperty('currentUi');
+    });
+    it('returns compact form schemas without requiring section expansion', async () => {
+        const handler = getToolHandler('geometra_form_schema');
+        mockState.formSchemas = [
+            {
+                formId: 'fm:0',
+                name: 'Application',
+                fieldCount: 4,
+                requiredCount: 3,
+                invalidCount: 0,
+                fields: [
+                    { id: 'ff:0.0', kind: 'text', label: 'Full name', required: true },
+                    { id: 'ff:0.1', kind: 'choice', label: 'Preferred location', required: true },
+                    { id: 'ff:0.2', kind: 'choice', label: 'Are you legally authorized to work in Germany?', options: ['Yes', 'No'], optionCount: 2 },
+                    { id: 'ff:0.3', kind: 'toggle', label: 'Share my profile for future roles', controlType: 'checkbox' },
+                ],
+            },
+        ];
+        const result = await handler({ maxFields: 20 });
+        const payload = JSON.parse(result.content[0].text);
+        expect(payload.forms).toEqual([
+            expect.objectContaining({
+                formId: 'fm:0',
+                fieldCount: 4,
+                requiredCount: 3,
+                invalidCount: 0,
+            }),
+        ]);
+    });
+    it('fills a form from ids and labels without echoing long essay content', async () => {
+        const longAnswer = 'B'.repeat(220);
+        const handler = getToolHandler('geometra_fill_form');
+        mockState.formSchemas = [
+            {
+                formId: 'fm:0',
+                name: 'Application',
+                fieldCount: 4,
+                requiredCount: 3,
+                invalidCount: 0,
+                fields: [
+                    { id: 'ff:0.0', kind: 'text', label: 'Full name', required: true },
+                    { id: 'ff:0.1', kind: 'choice', label: 'Are you legally authorized to work in Germany?', options: ['Yes', 'No'], optionCount: 2 },
+                    { id: 'ff:0.2', kind: 'toggle', label: 'Share my profile for future roles', controlType: 'checkbox' },
+                    { id: 'ff:0.3', kind: 'text', label: 'Why Geometra?' },
+                ],
+            },
+        ];
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 640 },
+            children: [
+                node('textbox', 'Full name', { value: 'Taylor Applicant', path: [0] }),
+                node('textbox', 'Why Geometra?', { value: longAnswer, path: [1] }),
+                node('checkbox', 'Share my profile for future roles', {
+                    path: [2],
+                    state: { checked: true },
+                }),
+            ],
+        });
+        const result = await handler({
+            valuesById: {
+                'ff:0.0': 'Taylor Applicant',
+            },
+            valuesByLabel: {
+                'Are you legally authorized to work in Germany?': true,
+                'Share my profile for future roles': true,
+                'Why Geometra?': longAnswer,
+            },
+            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(mockState.sendFieldChoice).toHaveBeenCalledWith(mockState.session, 'Are you legally authorized to work in Germany?', 'Yes', { exact: undefined, query: undefined }, undefined);
+        expect(payload).toMatchObject({
+            completed: true,
+            formId: 'fm:0',
+            requestedValueCount: 4,
+            fieldCount: 4,
+            successCount: 4,
+            errorCount: 0,
+        });
+        expect(steps[3]).toMatchObject({
+            kind: 'text',
+            fieldLabel: 'Why Geometra?',
+            valueLength: 220,
+            readback: { role: 'textbox', valueLength: 220 },
+        });
+    });
+    it('uses batched proxy fill for compact fill_form responses', async () => {
+        const handler = getToolHandler('geometra_fill_form');
+        mockState.sendFillFields.mockResolvedValueOnce({
+            status: 'acknowledged',
+            timeoutMs: 6000,
+            result: {
+                pageUrl: 'https://jobs.example.com/application',
+                invalidCount: 0,
+                alertCount: 0,
+                dialogCount: 0,
+                busyCount: 0,
+            },
+        });
+        mockState.formSchemas = [
+            {
+                formId: 'fm:0',
+                name: 'Application',
+                fieldCount: 3,
+                requiredCount: 2,
+                invalidCount: 0,
+                fields: [
+                    { id: 'ff:0.0', kind: 'text', label: 'Full name', required: true },
+                    { id: 'ff:0.1', kind: 'choice', label: 'Preferred location', required: true },
+                    { id: 'ff:0.2', kind: 'toggle', label: 'Share my profile for future roles', controlType: 'checkbox' },
+                ],
+            },
+        ];
+        mockState.currentA11yRoot = node('group', undefined, {
+            meta: { pageUrl: 'https://jobs.example.com/application', scrollX: 0, scrollY: 640 },
+            children: [
+                node('textbox', 'Full name', { value: 'Taylor Applicant', path: [0] }),
+                node('combobox', 'Preferred location', { value: 'Berlin, Germany', path: [1] }),
+                node('checkbox', 'Share my profile for future roles', {
+                    path: [2],
+                    state: { checked: true },
+                }),
+            ],
+        });
+        const result = await handler({
+            valuesById: {
+                'ff:0.0': 'Taylor Applicant',
+                'ff:0.1': 'Berlin, Germany',
+                'ff:0.2': true,
+            },
+            includeSteps: false,
+            detail: 'minimal',
+        });
+        const payload = JSON.parse(result.content[0].text);
+        expect(mockState.sendFillFields).toHaveBeenCalledWith(mockState.session, [
+            { kind: 'text', fieldLabel: 'Full name', value: 'Taylor Applicant' },
+            { kind: 'choice', fieldLabel: 'Preferred location', value: 'Berlin, Germany' },
+            {
+                kind: 'toggle',
+                label: 'Share my profile for future roles',
+                checked: true,
+                controlType: 'checkbox',
+            },
+        ]);
+        expect(mockState.sendFieldText).not.toHaveBeenCalled();
+        expect(mockState.sendFieldChoice).not.toHaveBeenCalled();
+        expect(mockState.sendSetChecked).not.toHaveBeenCalled();
+        expect(payload).toMatchObject({
+            completed: true,
+            execution: 'batched',
+            finalSource: 'proxy',
+            formId: 'fm:0',
+            fieldCount: 3,
+            successCount: 3,
+            errorCount: 0,
+            final: {
+                invalidCount: 0,
+                alertCount: 0,
+            },
+        });
+        expect(payload).not.toHaveProperty('steps');
+    });
 });
 describe('query and reveal tools', () => {
     beforeEach(() => {

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { buildA11yTree, buildCompactUiIndex, buildPageModel, expandPageSection, buildUiDelta, hasUiDelta, summarizeUiDelta, } from '../session.js';
+import { buildA11yTree, buildCompactUiIndex, buildFormSchemas, buildPageModel, expandPageSection, buildUiDelta, hasUiDelta, summarizeUiDelta, } from '../session.js';
 function node(role, name, bounds, options) {
     return {
         role,
@@ -237,6 +237,135 @@ describe('buildPageModel', () => {
         expect(model.forms[0]?.name).toBeUndefined();
     });
 });
+describe('buildFormSchemas', () => {
+    it('builds a compact fill-oriented schema and collapses repeated answer groups', () => {
+        const longEssay = 'Semantic browser automation should be reliable, compact, and predictable across large forms.';
+        const tree = node('group', undefined, { x: 0, y: 0, width: 1024, height: 768 }, {
+            children: [
+                node('form', 'Application', { x: 32, y: 32, width: 760, height: 1500 }, {
+                    path: [0],
+                    children: [
+                        node('textbox', 'Full name', { x: 48, y: 120, width: 320, height: 36 }, {
+                            path: [0, 0],
+                            state: { required: true },
+                        }),
+                        node('combobox', 'Preferred location', { x: 48, y: 180, width: 320, height: 36 }, {
+                            path: [0, 1],
+                            state: { required: true },
+                            value: 'Berlin, Germany',
+                        }),
+                        node('group', undefined, { x: 40, y: 260, width: 520, height: 96 }, {
+                            path: [0, 2],
+                            children: [
+                                node('text', 'Are you legally authorized to work in Germany?', { x: 48, y: 260, width: 360, height: 24 }, {
+                                    path: [0, 2, 0],
+                                }),
+                                node('button', 'Yes', { x: 48, y: 300, width: 88, height: 40 }, {
+                                    path: [0, 2, 1],
+                                    focusable: true,
+                                    state: { required: true },
+                                }),
+                                node('button', 'No', { x: 148, y: 300, width: 88, height: 40 }, {
+                                    path: [0, 2, 2],
+                                    focusable: true,
+                                }),
+                            ],
+                        }),
+                        node('checkbox', 'Share my profile for future roles', { x: 48, y: 400, width: 24, height: 24 }, {
+                            path: [0, 3],
+                            focusable: true,
+                            state: { checked: true },
+                        }),
+                        node('textbox', 'Why Geometra?', { x: 48, y: 480, width: 520, height: 180 }, {
+                            path: [0, 4],
+                            state: { required: true, invalid: true },
+                            validation: { error: 'Please enter at least 40 characters.' },
+                            value: longEssay,
+                        }),
+                    ],
+                }),
+            ],
+        });
+        const schemas = buildFormSchemas(tree);
+        expect(schemas).toHaveLength(1);
+        expect(schemas[0]).toMatchObject({
+            formId: 'fm:0',
+            name: 'Application',
+            fieldCount: 5,
+            requiredCount: 4,
+            invalidCount: 1,
+        });
+        expect(schemas[0]?.fields).toEqual([
+            expect.objectContaining({
+                kind: 'text',
+                label: 'Full name',
+                required: true,
+            }),
+            expect.objectContaining({
+                kind: 'choice',
+                label: 'Preferred location',
+                required: true,
+                value: 'Berlin, Germany',
+            }),
+            expect.objectContaining({
+                kind: 'choice',
+                label: 'Are you legally authorized to work in Germany?',
+                required: true,
+                optionCount: 2,
+                options: ['Yes', 'No'],
+            }),
+            expect.objectContaining({
+                kind: 'toggle',
+                label: 'Share my profile for future roles',
+                checked: true,
+                controlType: 'checkbox',
+            }),
+            expect.objectContaining({
+                kind: 'text',
+                label: 'Why Geometra?',
+                required: true,
+                invalid: true,
+                valueLength: longEssay.length,
+            }),
+        ]);
+    });
+    it('prefers question prompts over nearby explanatory copy for grouped choices', () => {
+        const tree = node('group', undefined, { x: 0, y: 0, width: 900, height: 700 }, {
+            children: [
+                node('form', 'Application', { x: 20, y: 20, width: 760, height: 480 }, {
+                    path: [0],
+                    children: [
+                        node('group', undefined, { x: 32, y: 80, width: 520, height: 120 }, {
+                            path: [0, 0],
+                            children: [
+                                node('text', 'Will you now or in the future require sponsorship?', { x: 40, y: 80, width: 420, height: 24 }, {
+                                    path: [0, 0, 0],
+                                }),
+                                node('text', 'This intentionally repeats Yes / No labels to test contextual disambiguation.', { x: 40, y: 112, width: 520, height: 24 }, {
+                                    path: [0, 0, 1],
+                                }),
+                                node('button', 'Yes', { x: 40, y: 152, width: 88, height: 40 }, {
+                                    path: [0, 0, 2],
+                                    focusable: true,
+                                }),
+                                node('button', 'No', { x: 140, y: 152, width: 88, height: 40 }, {
+                                    path: [0, 0, 3],
+                                    focusable: true,
+                                }),
+                            ],
+                        }),
+                    ],
+                }),
+            ],
+        });
+        const schema = buildFormSchemas(tree)[0];
+        expect(schema?.fields[0]).toMatchObject({
+            kind: 'choice',
+            label: 'Will you now or in the future require sponsorship?',
+            options: ['Yes', 'No'],
+        });
+    });
+});
 describe('buildUiDelta', () => {
     it('captures opened dialogs, state changes, and list count changes', () => {
         const before = node('group', undefined, { x: 0, y: 0, width: 1024, height: 768 }, {