@weavetab/mcp 2.5.0-beta.2 → 2.5.0-beta.4

package/dist/tools/checkpoint.js

@@ -0,0 +1,271 @@
+/**
+ * Weavetab — tools/checkpoint.ts
+ * browser_checkpoint: Session time-travel and rollback.
+ *
+ * Captures and restores named checkpoints of browser state:
+ *   - Cookies (HttpOnly and Secure via CDP Network)
+ *   - LocalStorage & SessionStorage
+ *   - URL, page title, and viewport scroll position
+ *   - Optional lightweight DOM snapshot
+ *
+ * Saves tokens and time when trial-and-error automation branches fail.
+ *
+ * Weavetab by fy2ne
+ */
+import { logAction } from "../audit/logger.js";
+import { recordAction } from "../intelligence/trail.js";
+import { clearTabCache } from "../state/cache.js";
+import { sessionRegistry } from "../state/session.js";
+import { getConfigAgentId } from "../config/loader.js";
+// In-memory checkpoint registry keyed by targetId -> name -> CheckpointData
+const checkpointRegistry = new Map();
+export function getCheckpointsForTarget(targetId) {
+    let map = checkpointRegistry.get(targetId);
+    if (!map) {
+        map = new Map();
+        checkpointRegistry.set(targetId, map);
+    }
+    return map;
+}
+export function clearAllCheckpoints() {
+    checkpointRegistry.clear();
+}
+export async function browserCheckpoint(session, args, config) {
+    let targetId = "default";
+    const active = sessionRegistry.getActive(getConfigAgentId(config));
+    if (active)
+        targetId = active.targetId;
+    const targetCheckpoints = getCheckpointsForTarget(targetId);
+    // ── ACTION: LIST ─────────────────────────────────────────────────────────────
+    if (args.action === "list") {
+        const list = Array.from(targetCheckpoints.values()).map((cp) => ({
+            name: cp.name,
+            url: cp.url,
+            title: cp.title,
+            timestamp: cp.timestamp,
+            cookiesCount: cp.cookies.length,
+            localStorageKeys: Object.keys(cp.localStorage).length,
+            sessionStorageKeys: Object.keys(cp.sessionStorage).length,
+            hasDomSnapshot: !!cp.domSnapshot,
+        }));
+        return {
+            success: true,
+            action: "list",
+            count: list.length,
+            checkpoints: list,
+        };
+    }
+    // ── ACTION: DELETE ───────────────────────────────────────────────────────────
+    if (args.action === "delete") {
+        if (!args.name) {
+            return {
+                success: false,
+                error_code: "INVALID_ARGS",
+                message: "Checkpoint 'name' is required for action 'delete'.",
+            };
+        }
+        const existed = targetCheckpoints.delete(args.name);
+        return {
+            success: existed,
+            action: "delete",
+            name: args.name,
+            message: existed
+                ? `Checkpoint '${args.name}' deleted.`
+                : `Checkpoint '${args.name}' not found.`,
+        };
+    }
+    // ── ACTION: SAVE ─────────────────────────────────────────────────────────────
+    if (args.action === "save") {
+        if (!args.name) {
+            return {
+                success: false,
+                error_code: "INVALID_ARGS",
+                message: "Checkpoint 'name' is required for action 'save'.",
+            };
+        }
+        const { Page, Network, Runtime } = session;
+        const { frameTree } = await Page.getFrameTree();
+        const currentUrl = frameTree.frame.url;
+        // 1. Snapshot cookies
+        let cookies = [];
+        try {
+            if (typeof Network.getCookies === "function") {
+                const res = await Network.getCookies({ urls: [currentUrl] });
+                cookies = res.cookies || [];
+            }
+            else if (typeof Network.getAllCookies === "function") {
+                const res = await Network.getAllCookies();
+                cookies = res.cookies || [];
+            }
+        }
+        catch {
+            // Cookies best-effort
+        }
+        // 2. Snapshot LocalStorage, SessionStorage, Scroll, and Title
+        let storageData = {
+            localStorage: {},
+            sessionStorage: {},
+            scroll: { x: 0, y: 0 },
+            title: "",
+        };
+        try {
+            const evalRes = await Runtime.evaluate({
+                expression: `(function() {
+          var ls = {};
+          try {
+            for (var i = 0; i < localStorage.length; i++) {
+              var k = localStorage.key(i);
+              if (k) ls[k] = localStorage.getItem(k);
+            }
+          } catch(e) {}
+          var ss = {};
+          try {
+            for (var j = 0; j < sessionStorage.length; j++) {
+              var sk = sessionStorage.key(j);
+              if (sk) ss[sk] = sessionStorage.getItem(sk);
+            }
+          } catch(e) {}
+          return {
+            localStorage: ls,
+            sessionStorage: ss,
+            scroll: { x: window.scrollX || 0, y: window.scrollY || 0 },
+            title: document.title || ""
+          };
+        })()`,
+                returnByValue: true,
+            });
+            if (evalRes?.result?.value) {
+                storageData = evalRes.result.value;
+            }
+        }
+        catch {
+            // Runtime best-effort
+        }
+        // 3. Optional lightweight DOM capture
+        let domSnapshot;
+        if (args.includeDom) {
+            try {
+                const domRes = await Runtime.evaluate({
+                    expression: `document.documentElement.outerHTML.slice(0, 100000)`,
+                    returnByValue: true,
+                });
+                domSnapshot = domRes?.result?.value;
+            }
+            catch {
+                // ignore
+            }
+        }
+        const checkpoint = {
+            name: args.name,
+            url: currentUrl,
+            title: storageData.title,
+            timestamp: new Date().toISOString(),
+            cookies,
+            localStorage: storageData.localStorage,
+            sessionStorage: storageData.sessionStorage,
+            scroll: storageData.scroll,
+            domSnapshot,
+        };
+        targetCheckpoints.set(args.name, checkpoint);
+        logAction("browser_checkpoint", args.name, `Saved checkpoint at ${currentUrl}`);
+        recordAction({
+            timestamp: checkpoint.timestamp,
+            tool: "browser_checkpoint",
+            input: { action: "save", name: args.name, url: currentUrl },
+            result: { success: true },
+        });
+        return {
+            success: true,
+            action: "save",
+            name: args.name,
+            url: currentUrl,
+            title: storageData.title,
+            timestamp: checkpoint.timestamp,
+            cookiesCount: cookies.length,
+            localStorageKeysCount: Object.keys(storageData.localStorage).length,
+            sessionStorageKeysCount: Object.keys(storageData.sessionStorage).length,
+        };
+    }
+    // ── ACTION: RESTORE ──────────────────────────────────────────────────────────
+    if (args.action === "restore") {
+        if (!args.name) {
+            return {
+                success: false,
+                error_code: "INVALID_ARGS",
+                message: "Checkpoint 'name' is required for action 'restore'.",
+            };
+        }
+        const checkpoint = targetCheckpoints.get(args.name);
+        if (!checkpoint) {
+            return {
+                success: false,
+                error_code: "CHECKPOINT_NOT_FOUND",
+                message: `No checkpoint found with name '${args.name}'. Use action: 'list' to see available checkpoints.`,
+            };
+        }
+        const { Page, Network, Runtime } = session;
+        const { frameTree } = await Page.getFrameTree();
+        const currentUrl = frameTree.frame.url;
+        // 1. Navigate to checkpoint URL if different
+        if (currentUrl !== checkpoint.url) {
+            await Page.navigate({ url: checkpoint.url });
+            await Page.loadEventFired().catch(() => { });
+            await new Promise((r) => setTimeout(r, 400));
+        }
+        // 2. Restore Cookies
+        if (checkpoint.cookies && checkpoint.cookies.length > 0) {
+            try {
+                if (typeof Network.setCookies === "function") {
+                    await Network.setCookies({ cookies: checkpoint.cookies });
+                }
+            }
+            catch {
+                // Cookies best-effort
+            }
+        }
+        // 3. Restore LocalStorage, SessionStorage, and Scroll position
+        try {
+            await Runtime.evaluate({
+                expression: `(function(ls, ss, scroll) {
+          try {
+            localStorage.clear();
+            for (var k in ls) { localStorage.setItem(k, ls[k]); }
+          } catch(e) {}
+          try {
+            sessionStorage.clear();
+            for (var sk in ss) { sessionStorage.setItem(sk, ss[sk]); }
+          } catch(e) {}
+          if (scroll) {
+            window.scrollTo(scroll.x, scroll.y);
+          }
+        })(${JSON.stringify(checkpoint.localStorage)}, ${JSON.stringify(checkpoint.sessionStorage)}, ${JSON.stringify(checkpoint.scroll)})`,
+                returnByValue: false,
+            });
+        }
+        catch {
+            // Storage best-effort
+        }
+        // Invalidate cached action map for this target so fresh refs get generated
+        clearTabCache(targetId);
+        logAction("browser_checkpoint", args.name, `Restored checkpoint to ${checkpoint.url}`);
+        recordAction({
+            timestamp: new Date().toISOString(),
+            tool: "browser_checkpoint",
+            input: { action: "restore", name: args.name, targetUrl: checkpoint.url },
+            result: { success: true },
+        });
+        return {
+            success: true,
+            action: "restore",
+            name: args.name,
+            url: checkpoint.url,
+            title: checkpoint.title,
+            restoredTimestamp: checkpoint.timestamp,
+        };
+    }
+    return {
+        success: false,
+        error_code: "INVALID_ACTION",
+        message: `Unsupported action '${args.action}'. Supported actions: save, restore, list, delete.`,
+    };
+}

package/dist/tools/click.d.ts

@@ -33,4 +33,5 @@ export declare function weaveClick(session: CDP.Client, args: {
     x?: number;
     y?: number;
     include_map?: boolean;
+    mark?: number;
 }, config: Config): Promise<ClickResult | WeaveError>;

package/dist/tools/click.js

@@ -1,6 +1,6 @@
 // src/tools/click.ts
 // Priority 2: Sub-10ms Click Path & Predictive Action Queue
-import { buildActionMap, findAllMatches, safeSelector, toMarkdownTable, resolveByAria } from "../cdp/walker.js";
+import { buildActionMap, findAllMatches, safeSelector, toMarkdownTable, resolveByAria, recoverDetachedRef } from "../cdp/walker.js";
 import { logAction } from "../audit/logger.js";
 import { recordAction, getLoopDiagnostics } from "../intelligence/trail.js";
 import { waitForDOMStable } from "../sensors/guard.js";
@@ -15,6 +15,7 @@ import { sendToExtension } from "../cdp/helpers.js";
 import { labelCache } from "../cdp/label_cache.js";
 import { getBestSelectorForIntent, logMemorySuccess, logMemoryFailure } from "../intelligence/sessionMemory.js";
 import { verifyActionability, quickHitCheck } from "../sensors/actionability.js";
+import { marksGet } from "../intelligence/marks.js";
 /** Converts SelectorFingerprint (sessionMemory) to the format verifyActionability expects. */
 function fpToOpts(fingerprint) {
     if (!fingerprint)
@@ -34,6 +35,36 @@ export async function weaveClick(session, args, config) {
     const startMs = Date.now();
     const clientMatch = sessionRegistry.getAll().find(c => c.session === session);
     const targetId = clientMatch?.targetId ?? session.targetId ?? "default";
+    // ── MARK FAST PATH: resolve by SoM mark number ─────────────────────────────
+    // Highest priority — zero DOM walk, straight coordinate dispatch.
+    if (args.mark !== undefined) {
+        const entry = marksGet(targetId, args.mark);
+        if (!entry) {
+            return {
+                success: false,
+                error_code: "MARK_NOT_FOUND",
+                message: `[!] Mark [${args.mark}] not found. Call browser_map({ visual: true }) or browser_map({ visual: "auto" }) first to generate marks.`,
+            };
+        }
+        // Ghost-move to coordinates, then dispatch hardware click
+        await ghostMove(session, entry.x, entry.y, config).catch(() => { });
+        await Input.dispatchMouseEvent({ type: "mousePressed", x: entry.x, y: entry.y, button: "left", clickCount: 1 });
+        await Input.dispatchMouseEvent({ type: "mouseReleased", x: entry.x, y: entry.y, button: "left", clickCount: 1 });
+        const initialUrl = (await Page.getFrameTree()).frameTree.frame.url;
+        logAction("browser_click", initialUrl, `mark:${args.mark} @(${entry.x},${entry.y})`);
+        return {
+            success: true,
+            clicked: entry.label ?? `mark:${args.mark}`,
+            ref: entry.ref ?? `mark:${args.mark}`,
+            execution_ms: Date.now() - startMs,
+            tab_id: targetId,
+            url: initialUrl,
+            title: "",
+            url_changed: false,
+            dom_changed: false,
+            stuck_warning: false,
+        };
+    }
     // Track URL before click
     const initialUrl = (await Page.getFrameTree()).frameTree.frame.url;
     // 1. Resolve Element and Selector
@@ -56,8 +87,8 @@ export async function weaveClick(session, args, config) {
         if (memHit) {
             const actCheck = await verifyActionability(session, memHit.selector, {
                 fingerprint: fpToOpts(memHit.fingerprint),
-                stabilityTimeoutMs: config.actionabilityTimeoutMs ?? 400,
-                totalTimeoutMs: (config.actionabilityTimeoutMs ?? 400) * 3,
+                stabilityTimeoutMs: config.actionabilityTimeoutMs ?? 200,
+                totalTimeoutMs: (config.actionabilityTimeoutMs ?? 200) * 3,
             });
             if (actCheck.status === 'ACTIONABLE') {
                 args.id = memHit.selector;
@@ -101,6 +132,14 @@ export async function weaveClick(session, args, config) {
                 cacheActionMap(targetId, map);
                 element = map.elements.find((el) => el.id === reqId);
             }
+            // If still not found, trigger the SPA auto-recovery heuristic before hard-failing
+            if (!element && reqId.startsWith("w:")) {
+                const recovery = await recoverDetachedRef(session, targetId, reqId);
+                if (recovery.recovered && recovery.element) {
+                    element = recovery.element;
+                    sniperWarning = recovery.warning || "";
+                }
+            }
             // Fast-fail if still not found
             if (!element && reqId.startsWith("w:")) {
                 return {
@@ -210,7 +249,7 @@ export async function weaveClick(session, args, config) {
         }
         const loopDiag = getLoopDiagnostics("browser_click", element.id);
         if (loopDiag.severity === "critical") {
-            return { success: false, error_code: "STUCK_LOOP_WARNING", message: `[!] Loop detected: You have tried to click [${element.id}] ${loopDiag.strikes} times without success. Call browser_reset_loop_counter if this is a new task.` };
+            return { success: false, error_code: "STUCK_LOOP_WARNING", message: `[!] Loop detected: You have tried to click [${element.id}] ${loopDiag.strikes} times without success. Run browser_map({ force: true }) if this is a new task.` };
         }
         if (loopDiag.severity === "warning") {
             logAction("browser_click", element.id, `loop warning: ${loopDiag.strikes} consecutive strikes on [${element.id}]`);
@@ -220,8 +259,8 @@ export async function weaveClick(session, args, config) {
             const selector = safeSelector(element);
             if (selector) {
                 const actCheck = await verifyActionability(session, selector, {
-                    stabilityTimeoutMs: config.actionabilityTimeoutMs ?? 400,
-                    totalTimeoutMs: (config.actionabilityTimeoutMs ?? 400) * 4,
+                    stabilityTimeoutMs: config.actionabilityTimeoutMs ?? 200,
+                    totalTimeoutMs: (config.actionabilityTimeoutMs ?? 200) * 3,
                 });
                 if (actCheck.status === 'ACTIONABLE') {
                     coords = { x: actCheck.x, y: actCheck.y, visible: true };
@@ -236,7 +275,20 @@ export async function weaveClick(session, args, config) {
                     }
                 }
                 else if (actCheck.status === 'NOT_FOUND') {
-                    return { success: false, error_code: "ELEMENT_NOT_FOUND", message: `[!] Element ${selector} was in the cached map but no longer exists in the DOM. Run browser_map again to refresh refs.` };
+                    if (element.id.startsWith("w:")) {
+                        const recovery = await recoverDetachedRef(session, targetId, element.id, element);
+                        if (recovery.recovered && recovery.element) {
+                            element = recovery.element;
+                            coords = { x: element.x, y: element.y, visible: true };
+                            sniperWarning = recovery.warning || "";
+                        }
+                        else {
+                            return { success: false, error_code: "ELEMENT_NOT_FOUND", message: `[!] Element ${selector} was in the cached map but no longer exists in the DOM. Run browser_map again to refresh refs.` };
+                        }
+                    }
+                    else {
+                        return { success: false, error_code: "ELEMENT_NOT_FOUND", message: `[!] Element ${selector} was in the cached map but no longer exists in the DOM. Run browser_map again to refresh refs.` };
+                    }
                 }
                 else if (actCheck.status === 'INVISIBLE') {
                     return { success: false, error_code: "ELEMENT_INVISIBLE", message: `[!] Element ${selector} has zero dimensions (hidden or collapsed). Use browser_inspect to check display/visibility, or scroll to reveal it.` };
@@ -272,15 +324,15 @@ export async function weaveClick(session, args, config) {
     async function performClick(cx, cy) {
         await ghostMove(session, cx, cy, config, element_.label);
         sendToExtension(session, { type: 'Weavetab_STATE', cursor: { x: cx, y: cy }, state: 'clicking', ripple: { cx, cy } }).catch(() => { });
-        // ── Pre-dispatch hit-target check (Playwright Step 6) ──────────────────
-        // Verify the coordinate is still clear right before the event fires.
-        // This catches overlays/modals that appeared since verifyActionability ran.
+        // ── Pre-dispatch hit-target check (lightweight) ─────────────────────────
+        // verifyActionability already confirmed actionable; this is a last-chance race guard.
+        // We do NOT throw here — transient tooltips/overlays cause false positives.
+        // If genuinely blocked, the post-click stuck detection handles the fallback.
         const targetSel = safeSelector(element_) ?? "";
         if (targetSel) {
             const hitCheck = await quickHitCheck(session, cx, cy, targetSel);
             if (!hitCheck.clear) {
-                // Raise to performClick caller so the retry loop can try another alignment
-                throw Object.assign(new Error(hitCheck.blockerDescription ?? "hit-target blocked"), { code: "HIT_TARGET_BLOCKED" });
+                logAction("browser_click", targetSel, `[quickHitCheck] soft-blocked by ${hitCheck.blockerDescription ?? "unknown"} — proceeding anyway`);
             }
         }
         if (!config.headless)
@@ -299,13 +351,13 @@ export async function weaveClick(session, args, config) {
         // Check if a dialog was opened by the click immediately. If a dialog is open,
         // the click succeeded in triggering an action. Waiting for DOM stable will
         // just hang for 5-10s because Runtime.evaluate blocks on JS dialogs.
-        await new Promise(r => setTimeout(r, 100)); // give dialog time to trigger
+        await new Promise(r => setTimeout(r, 30)); // give dialog time to trigger
         if (hasOpenDialog(session)) {
             return { stuck: false, url: currentUrl, newMap: null, dialog_open: true };
         }
         await Promise.all([
-            waitForDOMStable(session, 50, 300),
-            waitForNetworkIdle(session, 50, 200).catch(() => { })
+            waitForDOMStable(session, 20, 150),
+            waitForNetworkIdle(session, 30, 150).catch(() => { })
         ]);
         const finalUrl = (await Page.getFrameTree()).frameTree.frame.url;
         // Fast path: URL changed → definitely not stuck, skip map rebuild
@@ -445,63 +497,15 @@ export async function weaveClick(session, args, config) {
         const stuck = false;
         return { stuck, url: finalUrl, newMap };
     }
-    let { x: clickX, y: clickY } = coords;
-    let hitTargetBlocked = false;
-    try {
-        await performClick(clickX, clickY);
-    }
-    catch (err) {
-        if (err?.code === "HIT_TARGET_BLOCKED") {
-            hitTargetBlocked = true;
-        }
-        else {
-            throw err;
-        }
-    }
+    const { x: clickX, y: clickY } = coords;
+    await performClick(clickX, clickY);
     // ── Post-click: get page state (URL, map, DOM delta) ─────────────────────
     // The 'stuck' flag is purely informational — it powers stuck_warning in the
-    // result. A dispatched, non-blocked click is NOT retried based on DOM delta
-    // alone, because: (a) many real interactions produce no measurable DOM delta
-    // (static buttons, CSS-only toggles, anchor scrolls); (b) retrying doubles the
-    // click on checkboxes/accordions, net-zeroing the primary action.
-    let postCheck = hitTargetBlocked
-        ? { stuck: true, url: initialUrl, newMap: null }
-        : await isClickStuck(initialUrl);
-    // SPA JS-click fallback: only when the first click was genuinely hit-blocked
-    if (hitTargetBlocked && element_) {
-        const sel = safeSelector(element_);
-        if (sel) {
-            try {
-                const { result: isButton } = await session.Runtime.evaluate({
-                    expression: `(function(s) {
-            var el = document.querySelector(s);
-            if (!el) return false;
-            var tag = el.tagName.toLowerCase();
-            var role = (el.getAttribute('role') || '').toLowerCase();
-            if (tag === 'button' || tag === 'a' || tag === 'input' || tag === 'label' || tag === 'select') return true;
-            if (['button','link','menuitem','menuitemcheckbox','menuitemradio',
-                 'radio','checkbox','tab','option','treeitem','gridcell','switch'].includes(role)) return true;
-            if (el.onclick || el.getAttribute('onclick')) return true;
-            if (el.isContentEditable || tag === 'summary') return true;
-            return false;
-          })(${JSON.stringify(sel)})`,
-                    returnByValue: true,
-                }).catch(() => ({ result: { value: false } }));
-                if (isButton?.value) {
-                    await session.Runtime.evaluate({
-                        expression: `(function(s) {
-              var el = document.querySelector(s);
-              if (el) { el.focus(); el.click(); }
-            })(${JSON.stringify(sel)})`,
-                        returnByValue: false,
-                    }).catch(() => { });
-                    await new Promise(r => setTimeout(r, 300));
-                    postCheck = { stuck: false, url: initialUrl, newMap: null };
-                }
-            }
-            catch { /* non-fatal */ }
-        }
-    }
+    // result. A dispatched click is NOT retried based on DOM delta alone, because:
+    // (a) many real interactions produce no measurable DOM delta (static buttons,
+    //     CSS-only toggles, anchor scrolls);
+    // (b) retrying doubles the click on checkboxes/accordions, net-zeroing it.
+    const postCheck = await isClickStuck(initialUrl);
     const executionMs = Date.now() - startMs;
     const { stuck: isStuck, url: finalUrl, newMap } = postCheck;
     if (neededScroll) {

package/dist/tools/design_extract.js

@@ -630,7 +630,7 @@ ${tailwindPath ? "4. `tailwind.theme.json` — Tailwind CSS `theme.extend` confi
                     htmlBytes: beautifulHtml.length
                 }
             },
-            message: `Design extracted successfully to ${targetDir}. Saved tokens.json, template.html, styles.css, and README.md.`
+            message: `design saved to ${targetDir}. Saved tokens.json, template.html, styles.css, and README.md.`
         };
     }
     finally {

package/dist/tools/eval.js

@@ -77,7 +77,7 @@ export async function browserEval(session, options, _config) {
     // result.value is undefined and result.description is unhelpfully a type string.
     // Return a clear message so agents know the eval succeeded — it just returned no value.
     const rawResult = result.type === 'undefined'
-        ? "(expression ran successfully — returned undefined. To get a confirmation value, append ; 'ok' or return a string explicitly.)"
+        ? "(eval returned undefined. append ; 'ok' or return a string explicitly.)"
         : result.value !== undefined ? result.value : result.description;
     const redactedResult = typeof rawResult === 'string'
         ? SessionSecretTracker.redact(targetId, rawResult)

package/dist/tools/fill.d.ts

@@ -1,7 +1,12 @@
 import CDP from "chrome-remote-interface";
 import type { Config } from "../config/loader.js";
 export interface FillField {
-    ref: string;
+    ref?: string;
+    selector?: string;
+    target?: string;
+    name?: string;
+    label?: string;
+    placeholder?: string;
     value: string;
 }
 /** A single cell write for Google Sheets / Canvas grid filling. */
@@ -15,6 +20,8 @@ export interface FillOptions {
     fields?: FillField[];
     submit?: string;
     scan_only?: boolean;
+    scan?: boolean;
+    inputs?: boolean;
     blast_mode?: boolean;
     /** Grid-fill mode for Google Sheets and other canvas-rendered spreadsheets.
      *  Provide cell addresses in A1 notation with their values.
@@ -27,6 +34,18 @@ export interface FillResult {
     succeeded: number;
     failed: number;
     submitted: boolean;
+    inputs?: Array<{
+        ref: string;
+        tag: string;
+        type: string;
+        name?: string;
+        label?: string;
+        placeholder?: string;
+        value: string;
+        focused?: boolean;
+        disabled?: boolean;
+        visible?: boolean;
+    }>;
     results: {
         ref: string;
         field_type: string;