@geometra/mcp 1.19.20 → 1.19.23

package/dist/session.js

@@ -1,3 +1,4 @@
+import { performance } from 'node:perf_hooks';
 import WebSocket from 'ws';
 import { spawnGeometraProxy, startEmbeddedGeometraProxy } from './proxy-spawn.js';
 let activeSession = null;
@@ -42,6 +43,11 @@ function clearReusableProxiesIfExited() {
 function touchReusableProxy(entry) {
     entry.lastUsedAt = Date.now();
 }
+function updateReusableProxySnapshotState(entry, session) {
+    if (session.tree && session.layout) {
+        entry.snapshotReady = true;
+    }
+}
 function closeReusableProxy(entry) {
     reusableProxies = reusableProxies.filter(candidate => candidate !== entry);
     if (entry.child) {
@@ -96,6 +102,7 @@ function setReusableProxy(proxy, wsUrl, opts) {
         existing.width = opts.width ?? 1280;
         existing.height = opts.height ?? 720;
         existing.pageUrl = opts.pageUrl;
+        existing.snapshotReady = opts.snapshotReady ?? existing.snapshotReady;
         existing.lastUsedAt = now;
         return;
     }
@@ -109,6 +116,7 @@ function setReusableProxy(proxy, wsUrl, opts) {
             width: opts.width ?? 1280,
             height: opts.height ?? 720,
             pageUrl: opts.pageUrl,
+            snapshotReady: opts.snapshotReady === true,
             lastUsedAt: now,
         };
         reusableProxies.push(entry);
@@ -132,19 +140,21 @@ function setReusableProxy(proxy, wsUrl, opts) {
         width: opts.width ?? 1280,
         height: opts.height ?? 720,
         pageUrl: opts.pageUrl,
+        snapshotReady: opts.snapshotReady === true,
         lastUsedAt: now,
     });
     enforceReusableProxyPoolLimit();
 }
 function rememberReusableProxyPageUrl(session) {
-    const pageUrl = session.cachedA11y?.meta?.pageUrl;
-    if (!pageUrl)
-        return;
     const entry = reusableProxyEntryForSession(session);
-    if (entry) {
+    if (!entry)
+        return;
+    updateReusableProxySnapshotState(entry, session);
+    const pageUrl = session.cachedA11y?.meta?.pageUrl;
+    if (pageUrl) {
         entry.pageUrl = pageUrl;
-        touchReusableProxy(entry);
     }
+    touchReusableProxy(entry);
 }
 function shutdownPreviousSession(opts) {
     const prev = activeSession;
@@ -199,6 +209,22 @@ function shutdownPreviousSession(opts) {
 function formatUnknownError(err) {
     return err instanceof Error ? err.message : String(err);
 }
+function reusableProxyMatchesOptions(entry, options) {
+    return (entry.pageUrl === options.pageUrl &&
+        entry.headless === (options.headless === true) &&
+        entry.slowMo === (options.slowMo ?? 0) &&
+        entry.width === (options.width ?? 1280) &&
+        entry.height === (options.height ?? 720));
+}
+function findExactReusableProxy(options) {
+    clearReusableProxiesIfExited();
+    return reusableProxies
+        .filter(entry => reusableProxyMatchesOptions(entry, options))
+        .sort((a, b) => {
+        const activeBonus = reusableProxyEntryIsActive(b) ? 1 : reusableProxyEntryIsActive(a) ? -1 : 0;
+        return activeBonus || b.lastUsedAt - a.lastUsedAt;
+    })[0];
+}
 function findReusableProxy(options) {
     clearReusableProxiesIfExited();
     const desiredHeadless = options.headless === true;
@@ -221,15 +247,106 @@ function findReusableProxy(options) {
         return score(b) - score(a) || b.lastUsedAt - a.lastUsedAt;
     })[0];
 }
+export async function prewarmProxy(options) {
+    clearReusableProxiesIfExited();
+    const existing = findExactReusableProxy(options);
+    if (existing) {
+        touchReusableProxy(existing);
+        return {
+            prepared: true,
+            reused: true,
+            transport: existing.runtime ? 'embedded' : 'child',
+            pageUrl: options.pageUrl,
+            wsUrl: existing.wsUrl,
+            headless: options.headless === true,
+            width: options.width ?? 1280,
+            height: options.height ?? 720,
+        };
+    }
+    let embeddedFailure;
+    try {
+        const { runtime, wsUrl } = await startEmbeddedGeometraProxy({
+            pageUrl: options.pageUrl,
+            port: options.port ?? 0,
+            headless: options.headless,
+            width: options.width,
+            height: options.height,
+            slowMo: options.slowMo,
+        });
+        try {
+            await runtime.ready;
+        }
+        catch (err) {
+            await runtime.close().catch(() => { });
+            throw err;
+        }
+        setReusableProxy({ runtime }, wsUrl, {
+            headless: options.headless,
+            slowMo: options.slowMo,
+            width: options.width,
+            height: options.height,
+            pageUrl: options.pageUrl,
+            snapshotReady: true,
+        });
+        return {
+            prepared: true,
+            reused: false,
+            transport: 'embedded',
+            pageUrl: options.pageUrl,
+            wsUrl,
+            headless: options.headless === true,
+            width: options.width ?? 1280,
+            height: options.height ?? 720,
+        };
+    }
+    catch (err) {
+        embeddedFailure = err;
+    }
+    try {
+        const { child, wsUrl } = await spawnGeometraProxy({
+            pageUrl: options.pageUrl,
+            port: options.port ?? 0,
+            headless: options.headless,
+            width: options.width,
+            height: options.height,
+            slowMo: options.slowMo,
+        });
+        setReusableProxy({ child }, wsUrl, {
+            headless: options.headless,
+            slowMo: options.slowMo,
+            width: options.width,
+            height: options.height,
+            pageUrl: options.pageUrl,
+        });
+        return {
+            prepared: true,
+            reused: false,
+            transport: 'child',
+            pageUrl: options.pageUrl,
+            wsUrl,
+            headless: options.headless === true,
+            width: options.width ?? 1280,
+            height: options.height ?? 720,
+        };
+    }
+    catch (spawnFailure) {
+        throw new Error(`Failed to prewarm embedded browser session: ${formatUnknownError(embeddedFailure)}\nChild-process proxy prewarm also failed: ${formatUnknownError(spawnFailure)}`);
+    }
+}
 async function attachToReusableProxy(proxy, options) {
-    const session = ((proxy.child && activeSession?.proxyChild === proxy.child) ||
+    const startedAt = performance.now();
+    const desiredWidth = options.width ?? proxy.width;
+    const desiredHeight = options.height ?? proxy.height;
+    const needsSnapshotKickoff = options.awaitInitialFrame !== false && !proxy.snapshotReady;
+    const reusedActiveSession = ((proxy.child && activeSession?.proxyChild === proxy.child) ||
         (proxy.runtime && activeSession?.proxyRuntime === proxy.runtime))
         ? activeSession
-        : await connect(proxy.wsUrl, {
-            skipInitialResize: true,
-            closePreviousProxy: false,
-            awaitInitialFrame: options.awaitInitialFrame,
-        });
+        : null;
+    const session = reusedActiveSession ?? await connect(proxy.wsUrl, {
+        skipInitialResize: true,
+        closePreviousProxy: false,
+        awaitInitialFrame: needsSnapshotKickoff ? false : options.awaitInitialFrame,
+    });
     if (!session) {
         throw new Error('Failed to attach to reusable proxy session');
     }
@@ -237,26 +354,53 @@ async function attachToReusableProxy(proxy, options) {
     session.proxyRuntime = proxy.runtime;
     session.proxyReusable = true;
     touchReusableProxy(proxy);
-    const desiredWidth = options.width ?? proxy.width;
-    const desiredHeight = options.height ?? proxy.height;
-    if (desiredWidth !== proxy.width || desiredHeight !== proxy.height) {
-        await sendAndWaitForUpdate(session, {
-            type: 'resize',
-            width: desiredWidth,
-            height: desiredHeight,
-        }, 5_000);
+    let resizeKickoffMs;
+    if (needsSnapshotKickoff || desiredWidth !== proxy.width || desiredHeight !== proxy.height) {
+        const resizeStartedAt = performance.now();
+        const resizeWait = await sendResizeAndWaitForUpdate(session, desiredWidth, desiredHeight, 5_000);
+        resizeKickoffMs = performance.now() - resizeStartedAt;
+        if (needsSnapshotKickoff && resizeWait.status === 'timed_out' && (!session.tree || !session.layout)) {
+            throw new Error('Timed out waiting for initial proxy snapshot after resize kickoff');
+        }
         proxy.width = desiredWidth;
         proxy.height = desiredHeight;
+        updateReusableProxySnapshotState(proxy, session);
     }
     const currentUrl = session.cachedA11y?.meta?.pageUrl ?? proxy.pageUrl;
+    let navigateMs;
     if (currentUrl !== options.pageUrl) {
+        const navigateStartedAt = performance.now();
         await sendNavigate(session, options.pageUrl, 15_000);
+        navigateMs = performance.now() - navigateStartedAt;
         proxy.pageUrl = options.pageUrl;
-    }
+        updateReusableProxySnapshotState(proxy, session);
+    }
+    const baseConnectTrace = !reusedActiveSession ? session.connectTrace : undefined;
+    session.connectTrace = {
+        mode: 'reused-proxy',
+        reused: true,
+        awaitInitialFrame: options.awaitInitialFrame !== false,
+        connectMs: baseConnectTrace?.totalMs ?? 0,
+        wsOpenMs: baseConnectTrace?.wsOpenMs,
+        firstFrameMs: baseConnectTrace?.firstFrameMs,
+        resolvedWithoutInitialFrame: baseConnectTrace?.resolvedWithoutInitialFrame,
+        snapshotKickoff: needsSnapshotKickoff,
+        resizeKickoffMs,
+        navigateMs,
+        totalMs: performance.now() - startedAt,
+    };
+    updateReusableProxySnapshotState(proxy, session);
     return session;
 }
 async function startFreshProxySession(options) {
+    const startedAt = performance.now();
+    const eagerInitialExtract = options.eagerInitialExtract !== undefined
+        ? options.eagerInitialExtract
+        : options.awaitInitialFrame !== false
+            ? undefined
+            : false;
     try {
+        const proxyStartStartedAt = performance.now();
         const { runtime, wsUrl } = await startEmbeddedGeometraProxy({
             pageUrl: options.pageUrl,
             port: options.port ?? 0,
@@ -264,7 +408,9 @@ async function startFreshProxySession(options) {
             width: options.width,
             height: options.height,
             slowMo: options.slowMo,
+            eagerInitialExtract,
         });
+        const proxyStartMs = performance.now() - proxyStartStartedAt;
         const session = await connect(wsUrl, {
             skipInitialResize: true,
             closePreviousProxy: false,
@@ -278,10 +424,25 @@ async function startFreshProxySession(options) {
             width: options.width,
             height: options.height,
             pageUrl: options.pageUrl,
+            snapshotReady: Boolean(session.tree && session.layout),
         });
+        const baseConnectTrace = session.connectTrace;
+        session.connectTrace = {
+            mode: 'fresh-proxy',
+            reused: false,
+            awaitInitialFrame: options.awaitInitialFrame !== false,
+            proxyStartMode: 'embedded',
+            proxyStartMs,
+            connectMs: baseConnectTrace?.totalMs,
+            wsOpenMs: baseConnectTrace?.wsOpenMs,
+            firstFrameMs: baseConnectTrace?.firstFrameMs,
+            resolvedWithoutInitialFrame: baseConnectTrace?.resolvedWithoutInitialFrame,
+            totalMs: performance.now() - startedAt,
+        };
         return session;
     }
     catch (e) {
+        const proxyStartStartedAt = performance.now();
         const { child, wsUrl } = await spawnGeometraProxy({
             pageUrl: options.pageUrl,
             port: options.port ?? 0,
@@ -289,7 +450,9 @@ async function startFreshProxySession(options) {
             width: options.width,
             height: options.height,
             slowMo: options.slowMo,
+            eagerInitialExtract,
         });
+        const proxyStartMs = performance.now() - proxyStartStartedAt;
         try {
             const session = await connect(wsUrl, {
                 skipInitialResize: true,
@@ -304,7 +467,21 @@ async function startFreshProxySession(options) {
                 width: options.width,
                 height: options.height,
                 pageUrl: options.pageUrl,
+                snapshotReady: Boolean(session.tree && session.layout),
             });
+            const baseConnectTrace = session.connectTrace;
+            session.connectTrace = {
+                mode: 'fresh-proxy',
+                reused: false,
+                awaitInitialFrame: options.awaitInitialFrame !== false,
+                proxyStartMode: 'child',
+                proxyStartMs,
+                connectMs: baseConnectTrace?.totalMs,
+                wsOpenMs: baseConnectTrace?.wsOpenMs,
+                firstFrameMs: baseConnectTrace?.firstFrameMs,
+                resolvedWithoutInitialFrame: baseConnectTrace?.resolvedWithoutInitialFrame,
+                totalMs: performance.now() - startedAt,
+            };
             return session;
         }
         catch (fallbackError) {
@@ -324,6 +501,7 @@ async function startFreshProxySession(options) {
  */
 export function connect(url, opts) {
     return new Promise((resolve, reject) => {
+        const startedAt = performance.now();
         clearReusableProxiesIfExited();
         shutdownPreviousSession({ closeProxy: opts?.closePreviousProxy ?? true });
         const ws = new WebSocket(url);
@@ -333,6 +511,12 @@ export function connect(url, opts) {
             tree: null,
             url,
             updateRevision: 0,
+            connectTrace: {
+                mode: 'direct-ws',
+                reused: false,
+                awaitInitialFrame: opts?.awaitInitialFrame !== false,
+                totalMs: 0,
+            },
             cachedA11y: null,
             cachedA11yRevision: -1,
             cachedFormSchemas: new Map(),
@@ -346,6 +530,9 @@ export function connect(url, opts) {
             }
         }, 10_000);
         ws.on('open', () => {
+            if (session.connectTrace) {
+                session.connectTrace.wsOpenMs = performance.now() - startedAt;
+            }
             if (!opts?.skipInitialResize) {
                 const width = opts?.width ?? 1024;
                 const height = opts?.height ?? 768;
@@ -354,6 +541,10 @@ export function connect(url, opts) {
             if (opts?.awaitInitialFrame === false && !resolved) {
                 resolved = true;
                 clearTimeout(timeout);
+                if (session.connectTrace) {
+                    session.connectTrace.resolvedWithoutInitialFrame = true;
+                    session.connectTrace.totalMs = performance.now() - startedAt;
+                }
                 activeSession = session;
                 resolve(session);
             }
@@ -366,9 +557,16 @@ export function connect(url, opts) {
                     session.tree = msg.tree;
                     session.updateRevision++;
                     invalidateSessionCaches(session);
+                    const connectTrace = session.connectTrace;
+                    if (connectTrace && connectTrace.firstFrameMs === undefined) {
+                        connectTrace.firstFrameMs = performance.now() - startedAt;
+                    }
                     if (!resolved) {
                         resolved = true;
                         clearTimeout(timeout);
+                        if (session.connectTrace) {
+                            session.connectTrace.totalMs = performance.now() - startedAt;
+                        }
                         activeSession = session;
                         resolve(session);
                     }
@@ -511,6 +709,17 @@ export function waitForUiCondition(session, predicate, timeoutMs) {
         check();
     });
 }
+function sendResizeAndWaitForUpdate(session, width, height, timeoutMs = 5_000) {
+    return new Promise((resolve, reject) => {
+        if (session.ws.readyState !== WebSocket.OPEN) {
+            reject(new Error('Not connected'));
+            return;
+        }
+        const startRevision = session.updateRevision;
+        session.ws.send(JSON.stringify({ type: 'resize', width, height }));
+        waitForNextUpdate(session, timeoutMs, undefined, startRevision).then(resolve).catch(reject);
+    });
+}
 /**
  * Send a click event at (x, y) and wait for the next frame/patch response.
  */
@@ -755,6 +964,12 @@ export function nodeIdForPath(path) {
 function formFieldIdForPath(path) {
     return `ff:${encodePath(path)}`;
 }
+function parseFormFieldId(id) {
+    const [prefix, encoded] = id.split(':', 2);
+    if (prefix !== 'ff' || !encoded)
+        return null;
+    return decodePath(encoded);
+}
 function sectionPrefix(kind) {
     if (kind === 'landmark')
         return 'lm';
@@ -1102,12 +1317,14 @@ function textPreview(node, maxItems) {
         !!sanitizeInlineName(candidate.name, 90));
     return dedupeStrings(texts.map(candidate => contentPreviewName(candidate)), maxItems);
 }
-function primaryAction(node) {
+function primaryAction(root, node) {
+    const context = nodeContextForNode(root, node);
     return {
         id: nodeIdForPath(node.path),
         role: node.role,
         ...(sanitizeInlineName(node.name, 80) ? { name: sanitizeInlineName(node.name, 80) } : {}),
         ...(cloneState(node.state) ? { state: cloneState(node.state) } : {}),
+        ...(context ? { context } : {}),
         bounds: cloneBounds(node.bounds),
     };
 }
@@ -1176,7 +1393,57 @@ function nearestPromptText(container, target) {
         .sort((a, b) => a.score - b.score)[0];
     return best?.text;
 }
-function nodeContext(root, node) {
+function nearestItemText(container, target) {
+    const normalizedTarget = normalizeUiText(target.name ?? '');
+    const best = collectDescendants(container, candidate => (candidate.role === 'heading' || candidate.role === 'link' || candidate.role === 'text') &&
+        !!sanitizeInlineName(candidate.name, 120) &&
+        pathKey(candidate.path) !== pathKey(target.path))
+        .filter(candidate => candidate.bounds.y <= target.bounds.y + Math.max(8, target.bounds.height))
+        .map(candidate => {
+        const text = sanitizeInlineName(candidate.name, 120);
+        if (!text)
+            return null;
+        if (normalizeUiText(text) === normalizedTarget)
+            return null;
+        const dy = Math.max(0, target.bounds.y - candidate.bounds.y);
+        const dx = Math.abs(target.bounds.x - candidate.bounds.x);
+        const headingBonus = candidate.role === 'heading' ? -36 : 0;
+        const linkBonus = candidate.role === 'link' ? -24 : 0;
+        const questionBonus = /\?\s*$/.test(text) ? 80 : 0;
+        const longTextPenalty = text.length > 90 ? 80 : text.length > 60 ? 40 : 0;
+        const pricePenalty = /^[^\p{L}\p{N}]*[$€£]/u.test(text) ? 120 : 0;
+        return { text, score: dy * 4 + dx + headingBonus + linkBonus + questionBonus + longTextPenalty + pricePenalty };
+    })
+        .filter((candidate) => candidate !== null)
+        .sort((a, b) => a.score - b.score)[0];
+    return best?.text;
+}
+function itemContext(root, node) {
+    if (node.role !== 'button' && node.role !== 'link')
+        return undefined;
+    const ancestors = ancestorNodes(root, node.path);
+    for (let index = ancestors.length - 1; index >= 0; index--) {
+        const ancestor = ancestors[index];
+        if (ancestor.role === 'article') {
+            const articleName = sectionDisplayName(ancestor, 'landmark');
+            if (articleName && normalizeUiText(articleName) !== normalizeUiText(node.name ?? ''))
+                return articleName;
+        }
+        if (ancestor.role === 'form' || ancestor.role === 'dialog' || ancestor.role === 'main' || ancestor.role === 'navigation' || ancestor.role === 'region') {
+            continue;
+        }
+        if (ancestor.role === 'listitem') {
+            const itemName = listItemName(ancestor);
+            if (itemName && normalizeUiText(itemName) !== normalizeUiText(node.name ?? ''))
+                return itemName;
+        }
+        const nearby = nearestItemText(ancestor, node);
+        if (nearby)
+            return nearby;
+    }
+    return undefined;
+}
+export function nodeContextForNode(root, node) {
     const ancestors = ancestorNodes(root, node.path);
     let prompt;
     const promptEligibleNode = node.role === 'radio' || node.role === 'button';
@@ -1200,20 +1467,26 @@ function nodeContext(root, node) {
         const kind = sectionKindForNode(ancestor);
         if (!kind)
             continue;
+        if (kind === 'list')
+            continue;
+        if (ancestor.role === 'article')
+            continue;
         section = sectionDisplayName(ancestor, kind);
         if (section)
             break;
     }
-    if (!prompt && !section)
+    const item = itemContext(root, node);
+    if (!prompt && !section && !item)
         return undefined;
     return {
         ...(prompt ? { prompt } : {}),
         ...(section ? { section } : {}),
+        ...(item ? { item } : {}),
     };
 }
 function toFieldModel(root, node, includeBounds = true) {
     const value = sanitizeInlineName(node.value, 120);
-    const context = nodeContext(root, node);
+    const context = nodeContextForNode(root, node);
     const visibility = buildVisibility(node.bounds, root.bounds);
     const scrollHint = buildScrollHint(node.bounds, root.bounds);
     return {
@@ -1230,7 +1503,7 @@ function toFieldModel(root, node, includeBounds = true) {
     };
 }
 function toActionModel(root, node, includeBounds = true) {
-    const context = nodeContext(root, node);
+    const context = nodeContextForNode(root, node);
     const visibility = buildVisibility(node.bounds, root.bounds);
     const scrollHint = buildScrollHint(node.bounds, root.bounds);
     return {
@@ -1269,14 +1542,14 @@ function isGroupedChoiceControl(node) {
     return node.role === 'radio' || node.role === 'checkbox' || (node.role === 'button' && node.focusable);
 }
 function groupedChoiceForNode(root, formNode, seed) {
-    const context = nodeContext(root, seed);
+    const context = nodeContextForNode(root, seed);
     const prompt = context?.prompt;
     if (!prompt)
         return null;
     const matchesPrompt = (candidate) => {
         if (!isGroupedChoiceControl(candidate))
             return false;
-        return nodeContext(root, candidate)?.prompt === prompt;
+        return nodeContextForNode(root, candidate)?.prompt === prompt;
     };
     const ancestors = ancestorNodes(root, seed.path);
     for (let index = ancestors.length - 1; index >= 0; index--) {
@@ -1294,7 +1567,7 @@ function groupedChoiceForNode(root, formNode, seed) {
     return controls.length >= 2 ? { container: formNode, prompt, controls } : null;
 }
 function simpleSchemaField(root, node) {
-    const context = nodeContext(root, node);
+    const context = nodeContextForNode(root, node);
     const label = fieldLabel(node) ?? sanitizeInlineName(node.name, 80) ?? context?.prompt;
     if (!label)
         return null;
@@ -1327,7 +1600,7 @@ function groupedSchemaField(root, grouped) {
     const options = dedupeStrings(optionEntries.map(entry => entry.label), 16);
     const selectedOptions = dedupeStrings(optionEntries.filter(entry => entry.selected).map(entry => entry.label), 16);
     const radioLike = optionEntries.every(entry => entry.role === 'radio' || entry.role === 'button');
-    const context = nodeContext(root, grouped.controls[0]);
+    const context = nodeContextForNode(root, grouped.controls[0]);
     return {
         id: formFieldIdForPath(grouped.container.path),
         kind: radioLike ? 'choice' : 'multi_choice',
@@ -1351,7 +1624,7 @@ function toggleSchemaField(root, node) {
     const label = schemaOptionLabel(node);
     if (!label)
         return null;
-    const context = nodeContext(root, node);
+    const context = nodeContextForNode(root, node);
     const controlType = node.role === 'radio' ? 'radio' : 'checkbox';
     return {
         id: formFieldIdForPath(node.path),
@@ -1555,7 +1828,7 @@ export function buildPageModel(root, options) {
     const primaryActions = compact.nodes
         .filter(node => node.focusable && ACTION_ROLES.has(node.role))
         .slice(0, maxPrimaryActions)
-        .map(node => primaryAction({
+        .map(node => primaryAction(root, findNodeByPath(root, node.path) ?? {
         role: node.role,
         name: node.name,
         state: node.state,
@@ -1596,6 +1869,45 @@ export function buildFormSchemas(root, options) {
         .filter(form => !options?.formId || sectionIdForPath('form', form.path) === options.formId)
         .map(form => buildFormSchemaForNode(root, form, options));
 }
+/**
+ * Required-field snapshot for automation: every required field in a form, including
+ * offscreen entries, annotated with visibility and scroll hints so agents do not
+ * mistake long-form fields for missing controls.
+ */
+export function buildFormRequiredSnapshot(root, options) {
+    const schemas = buildFormSchemas(root, {
+        formId: options?.formId,
+        maxFields: options?.maxFields,
+        onlyRequiredFields: true,
+        includeOptions: options?.includeOptions,
+        includeContext: options?.includeContext,
+    });
+    return schemas.map(schema => {
+        const parsedForm = parseSectionId(schema.formId);
+        const formNode = parsedForm ? findNodeByPath(root, parsedForm.path) : null;
+        const fields = schema.fields
+            .map(field => {
+            const fieldPath = parseFormFieldId(field.id);
+            const target = fieldPath ? findNodeByPath(root, fieldPath) ?? formNode : formNode;
+            if (!target)
+                return null;
+            return {
+                ...field,
+                bounds: cloneBounds(target.bounds),
+                visibility: buildVisibility(target.bounds, root.bounds),
+                scrollHint: buildScrollHint(target.bounds, root.bounds),
+            };
+        })
+            .filter((field) => field !== null);
+        return {
+            formId: schema.formId,
+            ...(schema.name ? { name: schema.name } : {}),
+            requiredCount: schema.requiredCount,
+            invalidCount: schema.invalidCount,
+            fields,
+        };
+    });
+}
 function headingModels(node, maxHeadings, includeBounds) {
     const headings = sortByBounds(collectDescendants(node, candidate => candidate.role === 'heading' && !!sanitizeInlineName(candidate.name, 80)));
     return headings.slice(0, maxHeadings).map(heading => ({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geometra/mcp",
-  "version": "1.19.20",
+  "version": "1.19.23",
   "description": "MCP server for Geometra — interact with running Geometra apps via the geometry protocol, no browser needed",
   "license": "MIT",
   "type": "module",
@@ -30,7 +30,7 @@
     "ui-testing"
   ],
   "dependencies": {
-    "@geometra/proxy": "^1.19.20",
+    "@geometra/proxy": "^1.19.23",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "ws": "^8.18.0",
     "zod": "^3.23.0"