@weavetab/mcp 2.5.0-beta.0

package/dist/tools/response.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Shared response interfaces for all interaction tools
+ * Standardizes the semantic response contract across WeaveTab tools
+ */
+import type { ElementState, VisibleFeedback } from "../cdp/verify.js";
+/**
+ * Base interface for all interaction tool responses
+ * Provides standard fields for success confirmation, strategy used, and state verification
+ */
+export interface InteractionResponse {
+    success: boolean;
+    /** Whether the effect was verified in DOM, not just dispatched */
+    confirmed: boolean;
+    /** What method/strategy was used for the interaction */
+    strategy: string;
+    /** Full element state after the action */
+    elementState?: ElementState;
+    /** Any toast/error/validation text that appeared after the action */
+    visibleFeedback?: VisibleFeedback[];
+    /** Suggested next action based on page context */
+    suggestedNext?: string;
+    /** Confidence score (0-1) based on verification strength */
+    confidence?: number;
+    /** True if result is degraded due to timeout or partial failure */
+    degraded?: boolean;
+}
+/**
+ * Extended response for click operations
+ */
+export interface ClickResponse extends InteractionResponse {
+    clicked: string;
+    ref: string;
+    execution_ms: number;
+    tab_id: string;
+    url: string;
+    title: string;
+    url_changed: boolean;
+    page_map?: string;
+    dom_changed: boolean;
+    stuck_warning: boolean;
+    stuck_hint?: string;
+    sniper_warning?: string;
+    _timing?: {
+        element_resolution_ms: number;
+        actionability_check_ms: number;
+        ghost_move_ms: number;
+        click_dispatch_ms: number;
+        stuck_check_ms: number;
+        fallback_retry_ms?: number;
+        recalibration_ms?: number;
+        map_build_count: number;
+    };
+    stuck_check_degraded?: boolean;
+}
+/**
+ * Extended response for type operations
+ */
+export interface TypeResponse extends InteractionResponse {
+    typed_into: string;
+    ref: string;
+    length: number;
+    execution_ms: number;
+    tab_id: string;
+    url: string;
+    title: string;
+    page_map?: string;
+    dom_changed: boolean;
+    stuck_warning: boolean;
+    stuck_hint?: string;
+    sniper_warning?: string;
+    memory_hit?: boolean;
+    delta?: any;
+}
+/**
+ * Extended response for fill operations (per-field)
+ */
+export interface FillFieldResponse extends InteractionResponse {
+    ref: string;
+    field_type: string;
+    success: boolean;
+    message: string;
+    value?: string;
+    /** Actual value read back from DOM after fill */
+    confirmedValue?: string;
+    /** Any validation error that appeared after fill */
+    validationError?: string;
+}
+/**
+ * Extended response for fill operations (overall)
+ */
+export interface FillResponse {
+    success: boolean;
+    total_fields: number;
+    succeeded: number;
+    failed: number;
+    submitted: boolean;
+    results: FillFieldResponse[];
+    execution_ms: number;
+}
+/**
+ * Extended response for navigate operations
+ */
+export interface NavigateResponse extends InteractionResponse {
+    url: string;
+    title: string;
+    tab_id: string;
+    /** Initial element count after navigation */
+    elementCount?: number;
+    /** Number of forms detected on page */
+    formCount?: number;
+    /** Whether cookie banners were dismissed */
+    cookiesDismissed?: boolean;
+}
+/**
+ * Error response structure
+ */
+export interface ErrorResponse {
+    success: false;
+    error_code: string;
+    message: string;
+    suggestion?: string;
+    human_needed?: boolean;
+    tab_id?: string;
+    url?: string;
+}
+/**
+ * Union type for all possible tool responses
+ */
+export type ToolResponse = InteractionResponse | ClickResponse | TypeResponse | FillResponse | FillFieldResponse | NavigateResponse | ErrorResponse;

package/dist/tools/response.js

@@ -0,0 +1,5 @@
+/**
+ * Shared response interfaces for all interaction tools
+ * Standardizes the semantic response contract across WeaveTab tools
+ */
+export {};

package/dist/tools/scrape.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Weavetab — tools/scrape.ts
+ * browser_scrape: Rapid structured data extraction using CSS selectors/XPath.
+ *
+ * Secret containment: any element marked data-wt-secret or type="password" has
+ * all requested attributes replaced with "[REDACTED]" in the returned result.
+ * This is evaluated inside the in-page expression so the secret value never
+ * crosses the CDP returnByValue boundary.
+ *
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface ScrapeOptions {
+    query: string;
+    type?: "css" | "xpath";
+    attributes?: string[];
+    multiple?: boolean;
+}
+export declare function browserScrape(session: CDP.Client, options: ScrapeOptions, _config: Config): Promise<{
+    success: boolean;
+    data: any[];
+    message: string;
+}>;

package/dist/tools/scrape.js

@@ -0,0 +1,140 @@
+export async function browserScrape(session, options, _config) {
+    const { query, type = "css", attributes = ["textContent"], multiple = true } = options;
+    const res = await session.Runtime.evaluate({
+        expression: `(function() {
+      const results = [];
+      let nodes = [];
+
+      try {
+        if (${JSON.stringify(type)} === 'css') {
+          if (${multiple}) {
+            nodes = Array.from(document.querySelectorAll(${JSON.stringify(query)}));
+            // Shadow DOM fallback: if nothing found, try the extension's deep-shadow query helper.
+            // This handles Vue/React components that attach to shadow roots.
+            if (nodes.length === 0 && window.__Weavetab_shadowQuery_all) {
+              try { nodes = Array.from(window.__Weavetab_shadowQuery_all(${JSON.stringify(query)})); } catch (_) {}
+            }
+          } else {
+            const node = document.querySelector(${JSON.stringify(query)})
+              || (window.__Weavetab_shadowQuery ? window.__Weavetab_shadowQuery(${JSON.stringify(query)}) : null);
+            if (node) nodes = [node];
+          }
+        } else if (${JSON.stringify(type)} === 'xpath') {
+          // Use SNAPSHOT type — immune to DOM mutations that would invalidate an ITERATOR mid-walk.
+          const snap = document.evaluate(${JSON.stringify(query)}, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+          const limit = ${multiple} ? snap.snapshotLength : Math.min(snap.snapshotLength, 1);
+          for (let i = 0; i < limit; i++) {
+            const n = snap.snapshotItem(i);
+            // Only Element nodes expose getAttribute / tagName / outerHTML safely.
+            if (n && n.nodeType === 1) nodes.push(n);
+          }
+        }
+      } catch (e) {
+        return { error: e.message };
+      }
+
+      const attrs = ${JSON.stringify(attributes)};
+      nodes.forEach(node => {
+        const item = {};
+
+        // Secret containment: redact any element marked as sensitive.
+        // data-wt-secret is set by browser_type_secret at injection time.
+        const isSecret = node.hasAttribute && (
+          node.hasAttribute('data-wt-secret') ||
+          (node.tagName === 'INPUT' && node.type === 'password')
+        );
+
+        if (isSecret) {
+          // Replace ALL requested attributes with [REDACTED] — value never crosses boundary
+          attrs.forEach(attr => { item[attr] = '[REDACTED]'; });
+        } else {
+          attrs.forEach(attr => {
+            if (attr === 'textContent' || attr === 'innerText') {
+              item[attr] = node[attr]?.trim() || '';
+            } else if (attr === 'outerHTML') {
+              item[attr] = node.outerHTML;
+            } else {
+              item[attr] = node.getAttribute(attr) || node[attr] || '';
+            }
+          });
+        }
+
+        results.push(item);
+      });
+
+      const isXpath = ${JSON.stringify(type)} === 'xpath';
+      const shadowFallback = !isXpath && nodes.length > 0 && !document.querySelector(${JSON.stringify(query)});
+      return { data: results, usedShadowFallback: shadowFallback };
+    })()`,
+        returnByValue: true
+    });
+    let val = res.result?.value;
+    if (val?.error) {
+        throw new Error(`Scrape failed (type=${type}, query=${query}): ${val.error}`);
+    }
+    // Async-render retry: if 0 results found (CSS or XPath), wait 300ms and retry once.
+    // Handles Vue transitions, React lazy rendering, and SPA route hydration.
+    if (!val?.data || val.data.length === 0) {
+        await new Promise(r => setTimeout(r, 300));
+        // Build a fresh count expression depending on selector type.
+        const countExpr = type === 'xpath'
+            ? `(function(){
+          try {
+            var s = document.evaluate(${JSON.stringify(query)}, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+            return s.snapshotLength;
+          } catch(e) { return 0; }
+        })()`
+            : `(function(){
+          var n = Array.from(document.querySelectorAll(${JSON.stringify(query)}));
+          if (n.length === 0 && window.__Weavetab_shadowQuery_all) {
+            try { n = Array.from(window.__Weavetab_shadowQuery_all(${JSON.stringify(query)})); } catch(_){}
+          }
+          return n.length;
+        })()`;
+        const retry = await session.Runtime.evaluate({ expression: countExpr, returnByValue: true }).catch(() => null);
+        if (retry?.result?.value && retry.result.value > 0) {
+            // Re-run full scrape now that elements exist.
+            // XPath path uses snapshot; CSS path uses querySelectorAll + shadow fallback.
+            const fullExpr = type === 'xpath'
+                ? `(function(){
+            var attrs = ${JSON.stringify(attributes)};
+            var snap = document.evaluate(${JSON.stringify(query)}, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+            var limit = ${multiple} ? snap.snapshotLength : Math.min(snap.snapshotLength, 1);
+            var results = [];
+            for (var i = 0; i < limit; i++) {
+              var node = snap.snapshotItem(i);
+              if (!node || node.nodeType !== 1) continue;
+              var item = {};
+              attrs.forEach(function(attr) {
+                if (attr === 'textContent' || attr === 'innerText') { item[attr] = (node[attr] || '').trim(); }
+                else if (attr === 'outerHTML') { item[attr] = node.outerHTML; }
+                else { item[attr] = node.getAttribute ? (node.getAttribute(attr) || node[attr] || '') : ''; }
+              });
+              results.push(item);
+            }
+            return { data: results };
+          })()`
+                : `(function(){
+            var nodes = Array.from(document.querySelectorAll(${JSON.stringify(query)}));
+            if (nodes.length === 0 && window.__Weavetab_shadowQuery_all) {
+              try { nodes = Array.from(window.__Weavetab_shadowQuery_all(${JSON.stringify(query)})); } catch(_){}
+            }
+            var attrs = ${JSON.stringify(attributes)};
+            return { data: nodes.map(function(node) {
+              var item = {};
+              attrs.forEach(function(attr) {
+                if (attr === 'textContent' || attr === 'innerText') { item[attr] = (node[attr] || '').trim(); }
+                else if (attr === 'outerHTML') { item[attr] = node.outerHTML; }
+                else { item[attr] = node.getAttribute(attr) || node[attr] || ''; }
+              });
+              return item;
+            })};
+          })()`;
+            const res2 = await session.Runtime.evaluate({ expression: fullExpr, returnByValue: true }).catch(() => null);
+            if (res2?.result?.value?.data) {
+                val = res2.result.value;
+            }
+        }
+    }
+    return { success: true, data: val?.data || [], message: `Extracted ${val?.data?.length || 0} elements` };
+}

package/dist/tools/screenshot.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Weavetab — tools/screenshot.ts
+ * browser_screenshot: Capture the current tab as a base64 PNG using Page.captureScreenshot.
+ *
+ * Use this tool when you need pixel-level vision of the page — e.g. to verify a visual
+ * result, read text in images, inspect canvas content, or confirm UI state that the DOM
+ * tree cannot describe. Returns a data URL the AI can interpret visually by default.
+ *
+ * Do NOT use this as a replacement for browser_map — use browser_map first to interact
+ * with elements. Use browser_screenshot only when visual confirmation is needed.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface ScreenshotOptions {
+    /** Capture format — "png" (lossless) or "jpeg" (smaller). Default: "png". */
+    format?: "png" | "jpeg";
+    /** JPEG quality 0–100. Only used when format is "jpeg". Default: 90. */
+    quality?: number;
+    /** If true, captures the full scrollable page, not just the viewport. Default: false. */
+    fullPage?: boolean;
+    /** Clip region {x, y, width, height, scale}. Overrides fullPage if set. */
+    clip?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** If false, keeps the WeaveTab UI overlay visible during capture.
+     * Default: true — overlay is always hidden from agent captures. */
+    hideOverlay?: boolean;
+}
+export type ScreenshotResult = {
+    success: true;
+    dataUrl: string;
+    width: number;
+    height: number;
+    format: string;
+};
+export declare function browserScreenshot(session: CDP.Client, options: ScreenshotOptions | undefined, _config: Config): Promise<ScreenshotResult>;

package/dist/tools/screenshot.js

@@ -0,0 +1,79 @@
+import { hideWeaveTabOverlay, restoreWeaveTabOverlay } from "../cdp/helpers.js";
+export async function browserScreenshot(session, options = {}, _config) {
+    const format = options.format ?? "png";
+    const quality = format === "jpeg" ? (options.quality ?? 90) : undefined;
+    // Get viewport dimensions
+    const { result: vpResult } = await session.Runtime.evaluate({
+        expression: `JSON.stringify({ w: window.innerWidth, h: window.innerHeight, dpr: window.devicePixelRatio || 1 })`,
+        returnByValue: true,
+    });
+    const vp = JSON.parse(vpResult.value);
+    let clip;
+    if (options.clip) {
+        clip = { ...options.clip, scale: 1 };
+    }
+    else if (options.fullPage) {
+        const { result: scrollResult } = await session.Runtime.evaluate({
+            expression: `JSON.stringify({ 
+        w: Math.max(document.documentElement.scrollWidth, document.body.scrollWidth), 
+        h: Math.max(document.documentElement.scrollHeight, document.body.scrollHeight) 
+      })`,
+            returnByValue: true,
+        });
+        const scroll = scrollResult?.value ? JSON.parse(scrollResult.value) : { w: vp.w, h: vp.h };
+        clip = { x: 0, y: 0, width: scroll.w, height: scroll.h, scale: 1 };
+    }
+    // ── Auto-compress: if viewport is wide, downscale to 1280px wide as JPEG 75% ──
+    // This cuts token cost by 40-60% with no quality loss for text content.
+    // Only applies when no explicit format/clip was requested.
+    const params = { format, captureBeyondViewport: !!options.fullPage };
+    if (!options.clip && !options.format && vp.w > 1280) {
+        const scale = 1280 / vp.w;
+        params.format = 'jpeg';
+        params.quality = 75;
+        params.clip = clip ?? { x: 0, y: 0, width: vp.w, height: vp.h, scale };
+        if (params.clip && params.clip.scale === 1) {
+            params.clip = { ...params.clip, scale };
+        }
+    }
+    else {
+        if (quality !== undefined)
+            params.quality = quality;
+        if (clip)
+            params.clip = clip;
+    }
+    // ── AI-blind: hide Weavetab overlay elements before screenshot ──────────────
+    // The chat panel, ghost cursor, thought bubble, HUD iframe, and all scripted
+    // UI are FOR THE USER only. The AI must never see or interact with them.
+    // hideOverlay defaults to true — only set to false if explicitly requested.
+    const shouldHide = options.hideOverlay !== false;
+    if (shouldHide) {
+        await hideWeaveTabOverlay(session);
+    }
+    let data;
+    try {
+        const res = await session.Page.captureScreenshot(params);
+        data = res.data;
+    }
+    catch (e) {
+        if (params.captureBeyondViewport) {
+            params.captureBeyondViewport = false;
+            delete params.clip;
+            const res = await session.Page.captureScreenshot(params);
+            data = res.data;
+        }
+        else {
+            throw e;
+        }
+    }
+    // Restore overlay visibility immediately after capture
+    if (shouldHide) {
+        await restoreWeaveTabOverlay(session);
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    const width = clip ? clip.width : vp.w;
+    const height = clip ? clip.height : vp.h;
+    const actualFormat = params.format || format;
+    const dataUrl = `data:image/${actualFormat};base64,${data}`;
+    return { success: true, dataUrl, width, height, format: actualFormat };
+}

package/dist/tools/scroll.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Weavetab — tools/scroll.ts
+ * Scrolls the page or a specific element in any direction.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+import type { WeaveError } from "./click.js";
+export interface ScrollResult {
+    success: true;
+    scrolled: string;
+    direction: string;
+    distance: number;
+    new_visible_count: number;
+    dom_changed: boolean;
+}
+export declare function browserScroll(session: CDP.Client, args: {
+    id?: string;
+    label?: string;
+    direction: "up" | "down" | "left" | "right";
+    distance?: number;
+    speed?: "human" | "read" | "fast";
+}, config: Config): Promise<ScrollResult | WeaveError>;

package/dist/tools/scroll.js

@@ -0,0 +1,196 @@
+/**
+ * Weavetab — tools/scroll.ts
+ * Scrolls the page or a specific element in any direction.
+ * Weavetab by fy2ne
+ */
+import { buildActionMap, findBestMatch, safeSelector } from "../cdp/walker.js";
+import { getCachedActionMap, cacheActionMap } from "../state/cache.js";
+import { computeDelta, storeSnapshot } from "../state/delta.js";
+import { waitForDOMStable } from "../sensors/guard.js";
+import { sessionRegistry } from "../state/session.js";
+import { logAction } from "../audit/logger.js";
+import { getConfigAgentId } from "../config/loader.js";
+import { sendToExtension } from "../cdp/helpers.js";
+function withTimeout(promise, ms, label) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms)),
+    ]);
+}
+// Track scroll frequency
+let recentScrolls = [];
+// helper for realistic human timing
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+const randomBetween = (min, max) => Math.random() * (max - min) + min;
+function applyEasing(t, type) {
+    switch (type) {
+        case 'quarticOut': return 1 - Math.pow(1 - t, 4);
+        case 'cubicOut': return 1 - Math.pow(1 - t, 3);
+        case 'linear': return t;
+        default: return t;
+    }
+}
+export async function browserScroll(session, args, config) {
+    let { id, label, direction, distance = 400, speed = "human" } = args;
+    if (distance < 0) {
+        distance = Math.abs(distance);
+        if (direction === "down")
+            direction = "up";
+        else if (direction === "up")
+            direction = "down";
+        else if (direction === "left")
+            direction = "right";
+        else if (direction === "right")
+            direction = "left";
+    }
+    const now = Date.now();
+    recentScrolls = recentScrolls.filter(t => now - t < 5000);
+    recentScrolls.push(now);
+    if (recentScrolls.length > 3) {
+        speed = "fast";
+    }
+    const { DOM, Runtime, Input } = session;
+    let targetId = "default";
+    const active = sessionRegistry.getActive(getConfigAgentId(config));
+    if (active)
+        targetId = active.targetId;
+    const { frameTree } = await session.Page.getFrameTree();
+    const url = frameTree.frame.url;
+    // ── Scroll a specific element into view ────────────────────────────────────
+    if (id || label) {
+        const { sendToExtension } = await import("../cdp/helpers.js");
+        await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: 'scrolling to element...' } });
+        let map = getCachedActionMap(targetId, url);
+        if (!map) {
+            const _emptyMap = { url, title: '', elements: [], targetId };
+            map = await withTimeout(buildActionMap(session, { lite: true }, targetId), 5000, "scroll buildActionMap").catch(() => _emptyMap);
+            if (map.elements.length > 0)
+                cacheActionMap(targetId, map);
+        }
+        storeSnapshot(targetId, map.url, map.elements);
+        let element = id
+            ? map.elements.find((el) => el.id === id)
+            : null;
+        // Fast-fail for stale w: IDs
+        if (!element && id && id.startsWith('w:')) {
+            return { success: false, error_code: 'ELEMENT_NOT_FOUND', message: `[!] Ref '${id}' not found in current map. Call browser_map() first.` };
+        }
+        if (!element && label) {
+            element = findBestMatch(map.elements, label);
+            if (!element) {
+                const { resolveByAria } = await import("../cdp/walker.js");
+                const ariaEl = await withTimeout(resolveByAria(session, label), 2000, "resolveByAria label timeout").catch(() => null);
+                if (ariaEl) {
+                    element = map.elements.find((el) => el.id === ariaEl.id) || null;
+                }
+            }
+        }
+        if (!element && id && !id.startsWith("w:")) {
+            element = {
+                id: id,
+                label: id,
+                selector: id,
+                role: "element",
+                group: "utility",
+                depth: 0,
+                fingerprint: "selector:" + id,
+            };
+        }
+        if (!element) {
+            return {
+                success: false,
+                error_code: "ELEMENT_NOT_FOUND",
+                message: `[!] Could not find element matching "${id ?? label}"`,
+            };
+        }
+        const selector = safeSelector(element);
+        if (!selector) {
+            return { success: false, error_code: "SELECTOR_RESOLUTION_FAILED", message: `[!] Could not resolve safe selector for element` };
+        }
+        // ── 3. Element-level Scroll (CDP Wheel Event) ─────────────────────────
+        const scrollSelector = selector;
+        let elementFound = false;
+        try {
+            const res = await session.Runtime.evaluate({
+                expression: `(function(sel) {
+          const el = document.querySelector(sel) || (window.__Weavetab_shadowQuery ? window.__Weavetab_shadowQuery(sel) : null);
+          if (!el) return null;
+          const rect = el.getBoundingClientRect();
+          return {
+            x: rect.left + rect.width / 2,
+            y: rect.top + rect.height / 2
+          };
+        })(${JSON.stringify(scrollSelector)})`,
+                returnByValue: true
+            });
+            const coords = res.result?.value;
+            if (coords && coords.x !== undefined && coords.y !== undefined) {
+                elementFound = true;
+                // Dispatch CDP wheel event precisely over the element
+                await session.Input.dispatchMouseEvent({
+                    type: "mouseWheel",
+                    x: coords.x,
+                    y: coords.y,
+                    deltaX: direction === "right" ? distance : (direction === "left" ? -distance : 0),
+                    deltaY: direction === "down" ? distance : (direction === "up" ? -distance : 0)
+                });
+                await new Promise(r => setTimeout(r, 100)); // allow scroll to settle
+            }
+        }
+        catch { /* ignore */ }
+        if (!elementFound) {
+            return { success: false, error_code: "SCROLL_TARGET_NOT_FOUND", message: `Element ${id ?? label} not found or not visible` };
+        }
+    }
+    else {
+        // ── Inertial Physics Scroll ────────────────────────────────────────────────
+        const profiles = {
+            human: { steps: 12, easing: 'quarticOut', baseDelay: 16 },
+            read: { steps: 25, easing: 'linear', baseDelay: 40 },
+            fast: { steps: 6, easing: 'cubicOut', baseDelay: 8 },
+        };
+        const profile = profiles[speed];
+        const totalPx = direction === 'down' ? distance : direction === 'up' ? -distance : 0;
+        const totalPxX = direction === 'right' ? distance : direction === 'left' ? -distance : 0;
+        let map = getCachedActionMap(targetId, url);
+        if (!map) {
+            map = await buildActionMap(session, { lite: true }, targetId);
+            cacheActionMap(targetId, map);
+        }
+        storeSnapshot(targetId, map.url, map.elements);
+        const viewportRes = await session.Runtime.evaluate({
+            expression: `JSON.stringify({ x: window.innerWidth / 2, y: window.innerHeight / 2 })`,
+            returnByValue: true
+        }).catch(() => null);
+        const vp = viewportRes?.result?.value ? JSON.parse(viewportRes.result.value) : { x: 400, y: 400 };
+        await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: `scrolling page ${direction}` } });
+        for (let i = 0; i < profile.steps; i++) {
+            const t = (i + 1) / profile.steps;
+            const eased = applyEasing(t, profile.easing);
+            const prevEased = applyEasing(i / profile.steps, profile.easing);
+            const chunkY = (eased - prevEased) * totalPx;
+            const chunkX = (eased - prevEased) * totalPxX;
+            await Input.dispatchMouseEvent({
+                type: 'mouseWheel',
+                x: vp.x, y: vp.y,
+                deltaX: chunkX, deltaY: chunkY
+            });
+            await sleep(profile.baseDelay + Math.random() * 8);
+        }
+    }
+    await waitForDOMStable(session, 80, 600).catch(() => { });
+    await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: '' } });
+    const nextMap = await buildActionMap(session, { lite: true }, targetId);
+    cacheActionMap(targetId, nextMap);
+    const diff = computeDelta(targetId, nextMap.url, nextMap.elements);
+    const changesCount = diff ? diff.added.length + diff.removed.length + diff.changed.length : 0;
+    logAction("browser_scroll", direction, `${distance}px`);
+    return {
+        success: true,
+        scrolled: id ?? label ?? "window",
+        direction,
+        distance,
+        new_visible_count: nextMap.elements.length,
+        dom_changed: changesCount > 0,
+    };
+}

package/dist/tools/select.d.ts

@@ -0,0 +1,13 @@
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface SelectOptions {
+    nodeId?: number;
+    selector?: string;
+    ref?: string;
+    id?: string;
+    value: string;
+}
+export declare function browserSelect(session: CDP.Client, options: SelectOptions, _config: Config): Promise<{
+    success: boolean;
+    message: string;
+}>;