@skyramp/mcp 0.2.2 → 0.2.4

package/build/playwright/registerPlaywrightTools.js

@@ -40,11 +40,6 @@ export async function registerPlaywrightTools(server, options) {
         'browser_select_option',
         'browser_hover',
         'browser_drag',
-        'browser_mouse_move_xy',
-        'browser_mouse_click_xy',
-        'browser_mouse_drag_xy',
-        'browser_mouse_down',
-        'browser_mouse_up',
         'browser_file_upload',
         'browser_evaluate',
         'browser_tabs',
@@ -54,8 +49,11 @@ export async function registerPlaywrightTools(server, options) {
         'browser_assert',
         'browser_assert_api_request',
         'browser_assert_table_cell',
+        'browser_mouse_action',
+        'browser_visual_snapshot',
         'skyramp_export_zip',
         'skyramp_load_trace',
+        'browser_mouse_action',
         // DOM Analyzer tools (Phase C)
         'browser_blueprint',
         'browser_blueprint_diff',
@@ -92,26 +90,7 @@ function jsonSchemaToZod(schema) {
     const required = new Set(schema.required || []);
     const shape = {};
     for (const [key, prop] of Object.entries(properties)) {
-        let field;
-        switch (prop.type) {
-            case "string":
-                field = prop.enum
-                    ? z.enum(prop.enum)
-                    : z.string();
-                break;
-            case "number":
-            case "integer":
-                field = z.number();
-                break;
-            case "boolean":
-                field = z.boolean();
-                break;
-            case "array":
-                field = z.array(prop.items ? jsonSchemaPropertyToZod(prop.items) : z.unknown());
-                break;
-            default:
-                field = z.unknown();
-        }
+        let field = jsonSchemaPropertyToZod(prop);
         if (prop.description)
             field = field.describe(prop.description);
         if (prop.default !== undefined)
@@ -135,6 +114,24 @@ function jsonSchemaPropertyToZod(prop) {
             return z.boolean();
         case "array":
             return z.array(prop.items ? jsonSchemaPropertyToZod(prop.items) : z.unknown());
+        case "object": {
+            // Nested object (e.g. a clip rect). Recurse into its properties so the
+            // SDK registers a real object schema; without this it falls through to
+            // z.unknown(), which serializes the nested object as a string and the
+            // inner backend's z.object(...) then rejects it.
+            const nestedProps = prop.properties || {};
+            const nestedRequired = new Set(prop.required || []);
+            const nestedShape = {};
+            for (const [k, p] of Object.entries(nestedProps)) {
+                let f = jsonSchemaPropertyToZod(p);
+                if (p.description)
+                    f = f.describe(p.description);
+                if (!nestedRequired.has(k))
+                    f = f.optional();
+                nestedShape[k] = f;
+            }
+            return z.object(nestedShape);
+        }
         default:
             return z.unknown();
     }

package/build/prompts/testbot/testbot-prompts.js

@@ -128,6 +128,7 @@ ${userPrompt ? "Generate only the tests that the user requested from the Additio
 - Example: If enrichment reveals that sending \`discount_value\` without \`discount_type\` silently orphans the value (a concrete bug), complete all planned GENERATE items first, then generate this discovered scenario as an extra test and report it in \`newTestsCreated\`.
 - Total generated: Follow the "Budget: N generate" line in the Execution Plan. Process every GENERATE-tagged item in order. Backfill from ADDITIONAL candidates (highest-ranked first) until \`newTestsCreated\` reaches ${maxGenerate} or all candidates are exhausted.
 - **UI test priority**: If the PR scope assessment shows any UI/E2E budget OR \`uiContext.changedFrontendFiles\` is non-empty (the deterministic server signal — populated for all supported frontend file types including \`.tsx\`/\`.jsx\`/\`.vue\`/\`.svelte\`/\`.dart\`), you MUST attempt to generate at least one UI test. Use \`browser_navigate\` to the app's base URL — if the app responds, record a trace and generate the test.
+  **Flutter web apps:** Skyramp's Playwright tools automatically enable Flutter's accessibility semantics tree on every \`browser_navigate\` call — you do NOT need to manually click \`flt-semantics-placeholder\` or add any activation step to the trace. Do NOT log an \`issuesFound\` entry about Flutter canvas rendering or accessibility activation — this is handled transparently.
   **Skip only if one of these conditions is met:**
   - **(a) App is unreachable** — \`browser_navigate\` fails or connection is refused.
   - **(b) Unintegrated non-route component** — the changed file is a leaf component (not a framework route/entrypoint) that has no integration point in the running app. To confirm:

package/node_modules/playwright/lib/mcp/skyramp/common/mouseActions.js

@@ -0,0 +1,123 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mouseActions_exports = {};
+__export(mouseActions_exports, {
+  DEFAULT_DRAG_STEPS: () => DEFAULT_DRAG_STEPS,
+  decodeModifierKeys: () => decodeModifierKeys,
+  decomposeDrag: () => decomposeDrag,
+  mouseActionToJsonl: () => mouseActionToJsonl,
+  mouseJsonlToCode: () => mouseJsonlToCode
+});
+module.exports = __toCommonJS(mouseActions_exports);
+const DEFAULT_DRAG_STEPS = 10;
+function decodeModifierKeys(mask, platform = typeof process !== "undefined" ? process.platform : "linux") {
+  if (!mask)
+    return [];
+  const keys = [];
+  if (mask & 1) keys.push("Alt");
+  if ((mask & 6) === 6) {
+    keys.push(platform === "darwin" ? "Meta" : "Control");
+  } else {
+    if (mask & 2) keys.push("Control");
+    if (mask & 4) keys.push("Meta");
+  }
+  if (mask & 8) keys.push("Shift");
+  return keys;
+}
+function decomposeDrag(start, end, steps = DEFAULT_DRAG_STEPS) {
+  return [
+    { name: "mouse.move", position: start },
+    { name: "mouse.down" },
+    { name: "mouse.move", position: end, steps },
+    { name: "mouse.up" }
+  ];
+}
+function mouseActionToJsonl(params) {
+  const button = params.button ?? "left";
+  const modifiers = params.modifiers ?? 0;
+  switch (params.action) {
+    case "move": {
+      if (params.x === void 0 || params.y === void 0)
+        return { error: 'mouse action "move" requires x and y.' };
+      const move = params.steps !== void 0 ? { name: "mouse.move", position: { x: params.x, y: params.y }, steps: params.steps } : { name: "mouse.move", position: { x: params.x, y: params.y } };
+      return { actions: [move] };
+    }
+    case "down":
+      return { actions: [button === "left" ? { name: "mouse.down" } : { name: "mouse.down", button }] };
+    case "up":
+      return { actions: [button === "left" ? { name: "mouse.up" } : { name: "mouse.up", button }] };
+    case "wheel": {
+      if (params.deltaX === void 0 && params.deltaY === void 0)
+        return { error: 'mouse action "wheel" requires deltaX and/or deltaY.' };
+      if (params.x === void 0 || params.y === void 0)
+        return { error: 'mouse action "wheel" requires x and y (the scroll target) so the pointer is moved there before scrolling.' };
+      const position = { x: params.x, y: params.y };
+      return { actions: [
+        { name: "mouse.move", position },
+        { name: "mouse.wheel", position, deltaX: params.deltaX ?? 0, deltaY: params.deltaY ?? 0, modifiers }
+      ] };
+    }
+    case "click": {
+      if (params.x === void 0 || params.y === void 0)
+        return { error: 'mouse action "click" requires x and y.' };
+      return { actions: [{ name: "click", selector: "body", position: { x: params.x, y: params.y }, button, modifiers, clickCount: params.clickCount ?? 1 }] };
+    }
+    case "drag": {
+      if (params.x === void 0 || params.y === void 0 || params.endX === void 0 || params.endY === void 0)
+        return { error: 'mouse action "drag" requires x, y, endX and endY.' };
+      return { actions: decomposeDrag({ x: params.x, y: params.y }, { x: params.endX, y: params.endY }, params.steps) };
+    }
+    default:
+      return { error: `Unknown mouse action: ${params.action}` };
+  }
+}
+function mouseJsonlToCode(a) {
+  switch (a.name) {
+    case "mouse.move":
+      return [a.steps !== void 0 ? `await page.mouse.move(${a.position.x}, ${a.position.y}, { steps: ${a.steps} });` : `await page.mouse.move(${a.position.x}, ${a.position.y});`];
+    case "mouse.down":
+      return [a.button && a.button !== "left" ? `await page.mouse.down({ button: '${a.button}' });` : `await page.mouse.down();`];
+    case "mouse.up":
+      return [a.button && a.button !== "left" ? `await page.mouse.up({ button: '${a.button}' });` : `await page.mouse.up();`];
+    case "mouse.wheel":
+      return withModifierLines(a.modifiers, `await page.mouse.wheel(${a.deltaX}, ${a.deltaY});`);
+    case "click": {
+      const opts = a.button !== "left" || a.clickCount !== 1 ? `, { button: '${a.button}', clickCount: ${a.clickCount} }` : "";
+      return withModifierLines(a.modifiers, `await page.mouse.click(${a.position.x}, ${a.position.y}${opts});`);
+    }
+  }
+}
+function withModifierLines(mask, line) {
+  const keys = decodeModifierKeys(mask);
+  if (!keys.length)
+    return [line];
+  return [
+    ...keys.map((k) => `await page.keyboard.down('${k}');`),
+    line,
+    ...[...keys].reverse().map((k) => `await page.keyboard.up('${k}');`)
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_DRAG_STEPS,
+  decodeModifierKeys,
+  decomposeDrag,
+  mouseActionToJsonl,
+  mouseJsonlToCode
+});

package/node_modules/playwright/lib/mcp/skyramp/common/visualSnapshot.js

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var visualSnapshot_exports = {};
+__export(visualSnapshot_exports, {
+  buildVisualSnapshotJsonl: () => buildVisualSnapshotJsonl,
+  nextSnapshotFilename: () => nextSnapshotFilename,
+  parseSnapshotCounter: () => parseSnapshotCounter,
+  visualSnapshotToCode: () => visualSnapshotToCode
+});
+module.exports = __toCommonJS(visualSnapshot_exports);
+const FILENAME_PREFIX = {
+  page: "page",
+  element: "el",
+  region: "region"
+};
+function nextSnapshotFilename(type, counter) {
+  return `${FILENAME_PREFIX[type]}-${String(counter).padStart(3, "0")}.png`;
+}
+function parseSnapshotCounter(type, filename) {
+  const m = new RegExp(`^${FILENAME_PREFIX[type]}-(\\d+)\\.png$`, "i").exec(filename);
+  return m ? parseInt(m[1], 10) : null;
+}
+function buildVisualSnapshotJsonl(input) {
+  if (!input.filename.toLowerCase().endsWith(".png"))
+    return { error: `visual snapshot filename must end in .png (got "${input.filename}").` };
+  switch (input.snapshotType) {
+    case "page": {
+      const action = { name: "visualSnapshot", snapshotType: "page", filename: input.filename };
+      if (input.fullPage !== void 0)
+        action.fullPage = input.fullPage;
+      if (input.screenshotStyle !== void 0)
+        action.screenshotStyle = input.screenshotStyle;
+      return { action };
+    }
+    case "element": {
+      if (!input.selector)
+        return { error: 'visual snapshot "element" requires a resolved selector (pass a ref to the tool).' };
+      return { action: { name: "visualSnapshot", snapshotType: "element", filename: input.filename, selector: input.selector } };
+    }
+    case "region": {
+      const c = input.clip;
+      if (!c || c.width === void 0 || c.height === void 0 || c.x === void 0 || c.y === void 0)
+        return { error: 'visual snapshot "region" requires a clip { x, y, width, height }.' };
+      return { action: { name: "visualSnapshot", snapshotType: "region", filename: input.filename, clip: { x: c.x, y: c.y, width: c.width, height: c.height } } };
+    }
+    default:
+      return { error: `Unknown visual snapshot type: ${input.snapshotType}` };
+  }
+}
+function visualSnapshotToCode(a, locatorExpr) {
+  const q = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const file = q(a.filename);
+  switch (a.snapshotType) {
+    case "page": {
+      const opts = [];
+      if (a.fullPage)
+        opts.push("fullPage: true");
+      if (a.screenshotStyle)
+        opts.push(`style: '${q(a.screenshotStyle)}'`);
+      const optsStr = opts.length ? `, { ${opts.join(", ")} }` : "";
+      return `await expect(page).toHaveScreenshot('${file}'${optsStr});`;
+    }
+    case "element": {
+      const target = locatorExpr ? `page.${locatorExpr}` : `page.locator('${q(a.selector)}')`;
+      return `await expect(${target}).toHaveScreenshot('${file}');`;
+    }
+    case "region": {
+      const { x, y, width, height } = a.clip;
+      return `await expect(page).toHaveScreenshot('${file}', { clip: { x: ${x}, y: ${y}, width: ${width}, height: ${height} } });`;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildVisualSnapshotJsonl,
+  nextSnapshotFilename,
+  parseSnapshotCounter,
+  visualSnapshotToCode
+});

package/node_modules/playwright/lib/mcp/skyramp/loadTraceTool.js

@@ -31,6 +31,7 @@ module.exports = __toCommonJS(loadTraceTool_exports);
 var import_mcpBundle = require("playwright-core/lib/mcpBundle");
 var import_utils = require("playwright-core/lib/utils");
 var import_tool = require("../sdk/tool");
+var import_mouseActions = require("./common/mouseActions");
 const loadTraceSchema = {
   name: "skyramp_load_trace",
   title: "Load and replay a Skyramp trace",
@@ -103,6 +104,8 @@ function describeStep(action, index) {
     detail += ` = ${JSON.stringify(a.value)}`;
   else if (a.name === "press" && a.key !== void 0)
     detail += ` ${a.key}`;
+  else if (a.name === "visualSnapshot")
+    detail = `${a.snapshotType ?? ""}${a.filename ? ` ${a.filename}` : ""}`.trim();
   return `#${index + 1} ${a.name}${onPage}${detail ? ` ${detail}` : ""}`;
 }
 function listStepsFrom(allActions, fromIndex) {
@@ -183,6 +186,17 @@ function urlMatchesPattern(currentUrl, pattern) {
     return (0, import_utils.urlMatches)(void 0, currentUrl, pattern);
   return currentUrl.toLowerCase().includes(pattern.toLowerCase());
 }
+async function withMouseModifiers(page, mask, fn) {
+  const keys = (0, import_mouseActions.decodeModifierKeys)(mask);
+  for (const k of keys)
+    await page.keyboard.down(k);
+  try {
+    await fn();
+  } finally {
+    for (const k of [...keys].reverse())
+      await page.keyboard.up(k);
+  }
+}
 const DEFAULT_ACTION_TIMEOUT = 15e3;
 async function performClientAction(page, actionInContext) {
   const action = actionInContext.action;
@@ -215,6 +229,40 @@ async function performClientAction(page, actionInContext) {
     await page.keyboard.press(shortcut);
     return;
   }
+  if (action.name === "mouse.move") {
+    if (!action.position)
+      return;
+    if (action.steps !== void 0)
+      await page.mouse.move(action.position.x, action.position.y, { steps: action.steps });
+    else
+      await page.mouse.move(action.position.x, action.position.y);
+    return;
+  }
+  if (action.name === "mouse.down") {
+    if (action.button && action.button !== "left")
+      await page.mouse.down({ button: action.button });
+    else
+      await page.mouse.down();
+    return;
+  }
+  if (action.name === "mouse.up") {
+    if (action.button && action.button !== "left")
+      await page.mouse.up({ button: action.button });
+    else
+      await page.mouse.up();
+    return;
+  }
+  if (action.name === "mouse.wheel") {
+    await withMouseModifiers(page, action.modifiers, () => page.mouse.wheel(action.deltaX ?? 0, action.deltaY ?? 0));
+    return;
+  }
+  if (action.name === "click" && action.position && (!action.selector || action.selector === "body")) {
+    const button = action.button ?? "left";
+    const clickCount = action.clickCount ?? 1;
+    const needsOpts = button !== "left" || clickCount !== 1;
+    await withMouseModifiers(page, action.modifiers, () => needsOpts ? page.mouse.click(action.position.x, action.position.y, { button, clickCount }) : page.mouse.click(action.position.x, action.position.y));
+    return;
+  }
   if (!action.selector)
     return;
   const selector = buildFullSelector(actionInContext.frame.framePath, action.selector);

package/node_modules/playwright/lib/mcp/skyramp/mouseActionTool.js

@@ -0,0 +1,131 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mouseActionTool_exports = {};
+__export(mouseActionTool_exports, {
+  _schema: () => mouseActionSchema,
+  executeMouseAction: () => executeMouseAction,
+  mouseActionMcpTool: () => mouseActionMcpTool,
+  mouseActionSchema: () => mouseActionSchema
+});
+module.exports = __toCommonJS(mouseActionTool_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("../sdk/tool");
+var import_mouseActions = require("./common/mouseActions");
+const mouseActionSchema = {
+  name: "browser_mouse_action",
+  title: "Mouse action (coordinate-based)",
+  description: [
+    "Perform coordinate-based mouse interactions: drag-and-drop, slider adjustment, canvas/diagram manipulation, scrolling, and other gestures that operate on viewport pixel positions rather than element references.",
+    "Primary uses: drag an item between positions (drag), move a slider thumb (drag), pan/draw on a canvas (move/down/up), and scroll a region (wheel).",
+    "The `action` parameter selects the gesture:",
+    "- drag: press at (x, y), move to (endX, endY), release. Decomposed into low-level mouse events (move\u2192down\u2192move\u2192up) so it works for sliders, canvas, and custom drag-handles where high-level element drag fails.",
+    "- move / down / up: individual pointer steps for composing custom gestures.",
+    "- wheel: scroll by deltaX / deltaY at the pointer position.",
+    '- click: a single position click at (x, y). Use for canvas hotspots, or as a fallback for an interactive element that has no usable accessibility ref or is occluded by an overlay (where browser_click reports "intercepts pointer events"). For ordinary elements, prefer browser_click.',
+    "Coordinates are viewport pixels, obtained from a snapshot or screenshot."
+  ].join(" "),
+  inputSchema: import_mcpBundle.z.object({
+    action: import_mcpBundle.z.enum(["move", "down", "up", "click", "wheel", "drag"]).describe("The mouse action to perform."),
+    x: import_mcpBundle.z.number().optional().describe("X coordinate (viewport px). Required for move/click/wheel; the start X for drag."),
+    y: import_mcpBundle.z.number().optional().describe("Y coordinate (viewport px). Required for move/click/wheel; the start Y for drag."),
+    endX: import_mcpBundle.z.number().optional().describe("End X coordinate for drag."),
+    endY: import_mcpBundle.z.number().optional().describe("End Y coordinate for drag."),
+    button: import_mcpBundle.z.enum(["left", "right", "middle"]).optional().describe("Mouse button for down/up/click. Defaults to left."),
+    clickCount: import_mcpBundle.z.number().int().positive().optional().describe("Number of clicks for click (e.g. 2 for double-click). Defaults to 1."),
+    deltaX: import_mcpBundle.z.number().optional().describe("Horizontal scroll delta for wheel."),
+    deltaY: import_mcpBundle.z.number().optional().describe("Vertical scroll delta for wheel."),
+    steps: import_mcpBundle.z.number().int().positive().optional().describe("Intermediate move steps for move/drag (smoother movement)."),
+    modifiers: import_mcpBundle.z.number().int().min(0).max(15).optional().describe("Modifier bitmask (Alt=1, Control=2, Meta=4, Shift=8) for click/wheel. Range 0-15.")
+  }),
+  type: "action"
+};
+function mouseActionMcpTool() {
+  return (0, import_tool.toMcpTool)(mouseActionSchema);
+}
+async function executeMouseAction(page, params) {
+  const built = (0, import_mouseActions.mouseActionToJsonl)(params);
+  if ("error" in built)
+    return { result: { content: [{ type: "text", text: `### Error
+${built.error}` }], isError: true }, actions: [] };
+  if (!page)
+    return { result: { content: [{ type: "text", text: "### Error\nNo open page. Call browser_navigate first." }], isError: true }, actions: [] };
+  const code = [];
+  try {
+    for (const a of built.actions) {
+      code.push(...(0, import_mouseActions.mouseJsonlToCode)(a));
+      await runOne(page, a);
+    }
+  } catch (e) {
+    return { result: { content: [{ type: "text", text: `### Error
+Mouse action failed: ${e.message}` }], isError: true }, actions: [] };
+  }
+  return {
+    result: { content: [{ type: "text", text: `### Ran Playwright code
+${code.join("\n")}` }] },
+    actions: built.actions
+  };
+}
+async function runOne(page, a) {
+  switch (a.name) {
+    case "mouse.move":
+      if (a.steps !== void 0)
+        await page.mouse.move(a.position.x, a.position.y, { steps: a.steps });
+      else
+        await page.mouse.move(a.position.x, a.position.y);
+      return;
+    case "mouse.down":
+      if (a.button && a.button !== "left")
+        await page.mouse.down({ button: a.button });
+      else
+        await page.mouse.down();
+      return;
+    case "mouse.up":
+      if (a.button && a.button !== "left")
+        await page.mouse.up({ button: a.button });
+      else
+        await page.mouse.up();
+      return;
+    case "mouse.wheel":
+      await withModifiers(page, a.modifiers, () => page.mouse.wheel(a.deltaX, a.deltaY));
+      return;
+    case "click": {
+      const needsOpts = a.button !== "left" || a.clickCount !== 1;
+      await withModifiers(page, a.modifiers, () => needsOpts ? page.mouse.click(a.position.x, a.position.y, { button: a.button, clickCount: a.clickCount }) : page.mouse.click(a.position.x, a.position.y));
+      return;
+    }
+  }
+}
+async function withModifiers(page, mask, fn) {
+  const keys = (0, import_mouseActions.decodeModifierKeys)(mask);
+  for (const k of keys)
+    await page.keyboard.down(k);
+  try {
+    await fn();
+  } finally {
+    for (const k of [...keys].reverse())
+      await page.keyboard.up(k);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _schema,
+  executeMouseAction,
+  mouseActionMcpTool,
+  mouseActionSchema
+});

package/node_modules/playwright/lib/mcp/skyramp/traceRecordingBackend.js

@@ -46,11 +46,14 @@ var import_assertTool = require("./assertTool");
 var import_assertApiRequestTool = require("./assertApiRequestTool");
 var import_loadTraceTool = require("./loadTraceTool");
 var import_skyRampImport = require("./skyRampImport");
+var import_mouseActionTool = require("./mouseActionTool");
+var import_visualSnapshotTool = require("./visualSnapshotTool");
+var import_visualSnapshot = require("./common/visualSnapshot");
 var import_utils = require("playwright-core/lib/utils");
 var import_types = require("./types");
 const traceDebug = (0, import_utilsBundle.debug)("pw:mcp:trace");
 class TraceRecordingBackend {
-  // true while page.reload() is in progress — suppresses spurious popup tracking
+  // per-type baseline filename counter
   constructor(options) {
     this._trackedActions = [];
     this._initialized = false;
@@ -61,6 +64,8 @@ class TraceRecordingBackend {
     this._pendingPopupAlias = null;
     // popup alias to stamp on the NEXT tracked click
     this._reloading = false;
+    // true while page.reload() is in progress — suppresses spurious popup tracking
+    this._visualSnapshotCounters = { page: 0, element: 0, region: 0 };
     this._options = options || {};
     this._outputDir = options?.outputDir || process.cwd();
     this._tempDir = import_fs.default.mkdtempSync(import_path.default.join(import_os.default.tmpdir(), "skyramp-trace-"));
@@ -119,7 +124,7 @@ class TraceRecordingBackend {
   }
   async listTools() {
     const browserTools = await this._browserBackend.listTools();
-    return [...browserTools, (0, import_exportTool.exportZipMcpTool)(), (0, import_assertTool.assertMcpTool)(), (0, import_assertApiRequestTool.assertApiRequestMcpTool)(), (0, import_loadTraceTool.loadTraceMcpTool)()];
+    return [...browserTools, (0, import_exportTool.exportZipMcpTool)(), (0, import_assertTool.assertMcpTool)(), (0, import_assertApiRequestTool.assertApiRequestMcpTool)(), (0, import_loadTraceTool.loadTraceMcpTool)(), (0, import_mouseActionTool.mouseActionMcpTool)(), (0, import_visualSnapshotTool.visualSnapshotMcpTool)()];
   }
   async callTool(name, args, progress) {
     if (!this._initialized)
@@ -146,6 +151,14 @@ class TraceRecordingBackend {
       const parsed = import_loadTraceTool.loadTraceSchema.inputSchema.parse(args || {});
       return this._handleLoadTrace(parsed);
     }
+    if (name === import_mouseActionTool.mouseActionSchema.name) {
+      const parsed = import_mouseActionTool.mouseActionSchema.inputSchema.parse(args || {});
+      return this._handleMouseAction(parsed);
+    }
+    if (name === import_visualSnapshotTool.visualSnapshotSchema.name) {
+      const parsed = import_visualSnapshotTool.visualSnapshotSchema.inputSchema.parse(args || {});
+      return this._handleVisualSnapshot(parsed);
+    }
     if (name === import_assertTool.assertToolSchema.name) {
       const parsed = import_assertTool.assertToolSchema.inputSchema.parse(args || {});
       return this._handleAssert(parsed);
@@ -320,6 +333,120 @@ Reloaded current page: ${currentUrl}
   serverClosed() {
     void this._autoExportAndClose().catch(import_log.logUnhandledError);
   }
+  /**
+   * Execute a coordinate-based mouse action and track each decomposed sub-action
+   * (mouse.move/down/up/wheel or a position click) into _trackedActions so it is
+   * exported into the combined JSONL trace. The JSONL field shapes come straight
+   * from common/mouseActions, which is the single source of truth shared with
+   * the export and seeding paths.
+   */
+  async _handleMouseAction(params) {
+    const page = this._browserBackend.context?.currentTab()?.page;
+    const timestamp = Date.now();
+    const pageAlias = this._currentPageAlias;
+    const { result, actions } = await (0, import_mouseActionTool.executeMouseAction)(page, params);
+    if (result.isError)
+      return result;
+    actions.forEach((a, i) => {
+      this._trackedActions.push({
+        toolName: "browser_mouse_action",
+        args: a,
+        code: "",
+        // Stagger timestamps so a decomposed drag keeps its move<down<move<up order.
+        timestamp: timestamp + i,
+        pageAlias
+      });
+    });
+    traceDebug(`Tracked ${actions.length} mouse sub-action(s) for "${params.action}" on ${pageAlias}`);
+    return result;
+  }
+  /**
+   * Handle browser_visual_snapshot: record a `visualSnapshot` marker that
+   * exports to expect(...).toHaveScreenshot(filename), so the generated test
+   * pixel-compares against a baseline.
+   *
+   * This is marker-only by design: the baseline image is created/updated by
+   * Playwright on the first test run (into its snapshot dir), NOT captured here.
+   * Taking a live screenshot at record time would be throwaway, and browser_
+   * take_screenshot has no clip parameter, so a region screenshot could not even
+   * be honored — it would mislead by returning a full-viewport image. So we only
+   * emit the marker, mirroring browser_assert_api_request.
+   *
+   * For an element snapshot, the ref is still resolved to a durable selector via
+   * the same hover->selector path browser_assert uses (testid > role > text, with
+   * the snapshot-accessible-name fallback for brittle/Flutter ids); that also
+   * validates the ref exists. Iframe and GoJS-diagram snapshots from the recorder
+   * are out of scope here (see common/visualSnapshot.ts).
+   */
+  async _handleVisualSnapshot(params) {
+    const timestamp = Date.now();
+    const pageAlias = this._currentPageAlias;
+    const input = {
+      snapshotType: params.snapshotType,
+      filename: params.filename ?? this._nextSnapshotFilename(params.snapshotType),
+      fullPage: params.fullPage,
+      clip: params.clip
+    };
+    if (params.snapshotType === "element") {
+      if (!params.ref)
+        return { content: [{ type: "text", text: '### Error\nsnapshotType "element" requires a ref (from the latest browser_snapshot).' }], isError: true };
+      const resolved = await this._resolveRefToLocator(params.ref, params.element ?? "");
+      if (!resolved)
+        return { content: [{ type: "text", text: `### Error
+Could not resolve a durable selector for ref=${params.ref}. Take a fresh browser_snapshot and retry, or use snapshotType "region".` }], isError: true };
+      input.selector = resolved.selector;
+    }
+    const built = (0, import_visualSnapshot.buildVisualSnapshotJsonl)(input);
+    if ("error" in built)
+      return { content: [{ type: "text", text: `### Error
+${built.error}` }], isError: true };
+    this._visualSnapshotCounters[params.snapshotType]++;
+    this._advanceSnapshotCounterFor(params.snapshotType, input.filename);
+    this._trackedActions.push({
+      toolName: "browser_visual_snapshot",
+      args: built.action,
+      code: "",
+      timestamp,
+      pageAlias
+    });
+    traceDebug(`Tracked visualSnapshot (${params.snapshotType}) "${input.filename}" on ${pageAlias}`);
+    const targetDesc = params.snapshotType === "element" ? ` (${input.selector})` : params.snapshotType === "region" && params.clip ? ` (clip ${params.clip.width}x${params.clip.height} at ${params.clip.x},${params.clip.y})` : params.fullPage ? " (full page)" : "";
+    return { content: [{ type: "text", text: `### Visual snapshot recorded
+Baseline "${input.filename}" (${params.snapshotType})${targetDesc} recorded; the generated test will assert toHaveScreenshot against it. The baseline image is created on the first test run.` }] };
+  }
+  /** Next auto-generated baseline filename for a snapshot type (page-NNN.png, etc.). */
+  _nextSnapshotFilename(type) {
+    return (0, import_visualSnapshot.nextSnapshotFilename)(type, this._visualSnapshotCounters[type] + 1);
+  }
+  /**
+   * Resolve a snapshot ref to a durable Playwright selector, mirroring the
+   * element-resolution path of _handleAssert: hover to get the resolved code,
+   * parse it to a selector, and prefer a snapshot-accessible-name selector over
+   * a brittle raw-CSS id (the Flutter-durable fallback). Returns null if the ref
+   * can't be resolved.
+   */
+  async _resolveRefToLocator(ref, element) {
+    const hoverResult = await this._browserBackend.callTool("browser_hover", { element, ref });
+    if (hoverResult.isError)
+      return null;
+    const hoverCode = (0, import_response.parseResponse)(hoverResult)?.code ?? "";
+    const locatorMatch = hoverCode.match(/await\s+page\.(.*?)\.hover\(\)/s);
+    if (!locatorMatch)
+      return null;
+    const locatorExpr = locatorMatch[1].trim();
+    let parsed = this._codeToLocator(locatorExpr);
+    if (!parsed || parsed.locator.kind === "css") {
+      const snapResult = await this._browserBackend.callTool("browser_snapshot", {});
+      if (!snapResult.isError) {
+        const snapText = snapResult.content?.map((c) => c.type === "text" ? c.text : "").join("") || "";
+        const refLine = snapText.split("\n").find((l) => l.includes(`[ref=${ref}]`)) || "";
+        const fromSnapshot = this._extractLocatorForRef(refLine);
+        if (fromSnapshot)
+          parsed = fromSnapshot;
+      }
+    }
+    return parsed;
+  }
   /**
    * Load a prior Skyramp trace and replay it against the live browser, honoring
    * an optional stop point, then seed _trackedActions with the replayed actions
@@ -433,6 +560,8 @@ Continue recording with browser_* tools, then call skyramp_export_zip to write t
     const seeded = this._seedTrackedActionFields(a, locatorExpr);
     if (!seeded)
       return;
+    if (seeded.toolName === "browser_visual_snapshot")
+      this._advanceSnapshotCounterFor(seeded.args.snapshotType, seeded.args.filename);
     this._trackedActions.push({
       ...seeded,
       timestamp: action.startTime,
@@ -440,6 +569,19 @@ Continue recording with browser_* tools, then call skyramp_export_zip to write t
       framePath: action.frame.framePath?.length ? action.frame.framePath : void 0
     });
   }
+  /**
+   * Bump the per-type snapshot counter to at least the number embedded in a
+   * seeded baseline filename (`<prefix>-NNN.png`), so subsequently-recorded
+   * snapshots of that type don't reuse a loaded trace's filename. No-op if the
+   * filename doesn't carry a parseable counter.
+   */
+  _advanceSnapshotCounterFor(snapshotType, filename) {
+    if (!snapshotType || !filename || this._visualSnapshotCounters[snapshotType] === void 0)
+      return;
+    const n = (0, import_visualSnapshot.parseSnapshotCounter)(snapshotType, filename);
+    if (n !== null && n > this._visualSnapshotCounters[snapshotType])
+      this._visualSnapshotCounters[snapshotType] = n;
+  }
   /**
    * Build the { toolName, code, args } triple a seeded (replayed) action must
    * carry so it round-trips through skyRampExport.buildJsonlContent exactly as
@@ -455,6 +597,14 @@ Continue recording with browser_* tools, then call skyramp_export_zip to write t
    */
   _seedTrackedActionFields(a, locatorExpr) {
     const sq = (s) => `'${String(s).replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t")}'`;
+    if (a.name === "mouse.move" || a.name === "mouse.down" || a.name === "mouse.up" || a.name === "mouse.wheel") {
+      const args = this._seedMouseActionArgs(a);
+      if (!args)
+        return null;
+      return { toolName: "browser_mouse_action", code: "", args };
+    }
+    if (a.name === "click" && a.position && (!a.selector || a.selector === "body"))
+      return { toolName: "browser_mouse_action", code: "", args: { name: "click", selector: "body", position: a.position, button: a.button ?? "left", modifiers: a.modifiers ?? 0, clickCount: a.clickCount ?? 1 } };
     const SELECTOR_REQUIRED = /* @__PURE__ */ new Set(["click", "hover", "fill", "pressSequentially", "check", "uncheck", "select"]);
     if (SELECTOR_REQUIRED.has(a.name) && !locatorExpr)
       return null;
@@ -526,6 +676,73 @@ Continue recording with browser_* tools, then call skyramp_export_zip to write t
         return { toolName: "browser_assert", code: `assertChecked:${a.selector}:${!!a.checked}`, args: { type: "checked", selector: a.selector, checked: !!a.checked } };
       case "assertVisible":
         return { toolName: "browser_assert", code: `assertVisible:${a.selector}`, args: { type: "visible", selector: a.selector } };
+      case "visualSnapshot": {
+        const args = this._seedVisualSnapshotArgs(a);
+        return args ? { toolName: "browser_visual_snapshot", code: "", args } : null;
+      }
+      default:
+        return null;
+    }
+  }
+  /**
+   * Build the normalized JSONL args for a re-seeded visualSnapshot action,
+   * following the VisualSnapshotJsonl contract in common/visualSnapshot.ts. Only
+   * known fields per snapshotType are emitted; a snapshot missing its required
+   * field (element->selector, region->clip) or with an unsupported type
+   * (gojsDiagram is recorder-only) is rejected (returns null) so the caller
+   * skips it rather than exporting an invalid shape.
+   */
+  _seedVisualSnapshotArgs(a) {
+    if (!a.filename || !String(a.filename).toLowerCase().endsWith(".png"))
+      return null;
+    switch (a.snapshotType) {
+      case "page": {
+        const args = { name: "visualSnapshot", snapshotType: "page", filename: a.filename };
+        if (a.fullPage !== void 0)
+          args.fullPage = a.fullPage;
+        if (a.screenshotStyle !== void 0)
+          args.screenshotStyle = a.screenshotStyle;
+        return args;
+      }
+      case "element":
+        if (!a.selector)
+          return null;
+        return { name: "visualSnapshot", snapshotType: "element", filename: a.filename, selector: a.selector };
+      case "region": {
+        const c = a.clip;
+        if (!c || c.x === void 0 || c.y === void 0 || c.width === void 0 || c.height === void 0)
+          return null;
+        return { name: "visualSnapshot", snapshotType: "region", filename: a.filename, clip: { x: c.x, y: c.y, width: c.width, height: c.height } };
+      }
+      default:
+        return null;
+    }
+  }
+  /**
+   * Build the normalized JSONL args for a re-seeded coordinate mouse action
+   * (mouse.move/down/up/wheel), following the MouseJsonlAction contract in
+   * common/mouseActions.ts. Only known fields are emitted (so stray fields from
+   * the loaded trace line are not forwarded), wheel deltas/modifiers default to
+   * 0, and a move/wheel missing its position is rejected (returns null) so the
+   * caller skips it rather than exporting an invalid shape for the Go consumer.
+   */
+  _seedMouseActionArgs(a) {
+    switch (a.name) {
+      case "mouse.move": {
+        if (!a.position)
+          return null;
+        const args = { name: "mouse.move", position: a.position };
+        if (a.steps !== void 0)
+          args.steps = a.steps;
+        return args;
+      }
+      case "mouse.down":
+      case "mouse.up":
+        return a.button && a.button !== "left" ? { name: a.name, button: a.button } : { name: a.name };
+      case "mouse.wheel":
+        if (!a.position)
+          return null;
+        return { name: "mouse.wheel", position: a.position, deltaX: a.deltaX ?? 0, deltaY: a.deltaY ?? 0, modifiers: a.modifiers ?? 0 };
       default:
         return null;
     }
@@ -654,14 +871,26 @@ Could not extract selector from hover result.` }], isError: true };
     }
     const locatorExpr = locatorMatch[1].trim();
     let parsed = this._codeToLocator(locatorExpr);
-    if (!parsed) {
+    const snapResult = await this._browserBackend.callTool("browser_snapshot", {});
+    if (snapResult.isError) {
+      const errText = snapResult.content?.[0]?.type === "text" ? snapResult.content[0].text : "";
       return { content: [{ type: "text", text: `### Assertion Failed
-Could not parse locator: ${locatorExpr}` }], isError: true };
+Could not capture page snapshot to verify the assertion. ${errText}` }], isError: true };
     }
-    const snapResult = await this._browserBackend.callTool("browser_snapshot", {});
     const snapText = snapResult.content?.map((c) => c.type === "text" ? c.text : "").join("") || "";
     const snapLines = snapText.split("\n");
     const refLine = snapLines.find((l) => l.includes(`[ref=${params.ref}]`)) || "";
+    if (!parsed || parsed.locator.kind === "css") {
+      const fromSnapshot = this._extractLocatorForRef(refLine);
+      if (fromSnapshot) {
+        traceDebug(`Resolved assert selector from snapshot accessible name (hover code was ${parsed ? "brittle CSS" : "unparseable"}: ${locatorExpr})`);
+        parsed = fromSnapshot;
+      }
+    }
+    if (!parsed) {
+      return { content: [{ type: "text", text: `### Assertion Failed
+Could not parse locator: ${locatorExpr}` }], isError: true };
+    }
     const textMatch = refLine.match(/^\s*-\s*\w+\s+"([^"]*)"/);
     const elementText = textMatch?.[1] || "";
     const valueMatch = refLine.match(/\]:\s*(.+)$/);
@@ -739,6 +968,13 @@ ${details}` }]
     if (ariaRefMatch) {
       return null;
     }
+    const cssMatch = expr.match(/locator\(\s*['"]([#.][^'"]+)['"]\s*\)/);
+    if (cssMatch) {
+      return {
+        selector: cssMatch[1],
+        locator: { kind: "css", body: cssMatch[1], options: {} }
+      };
+    }
     return null;
   }
   /**

package/node_modules/playwright/lib/mcp/skyramp/visualSnapshotTool.js

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var visualSnapshotTool_exports = {};
+__export(visualSnapshotTool_exports, {
+  visualSnapshotMcpTool: () => visualSnapshotMcpTool,
+  visualSnapshotSchema: () => visualSnapshotSchema
+});
+module.exports = __toCommonJS(visualSnapshotTool_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("../sdk/tool");
+const visualSnapshotSchema = {
+  name: "browser_visual_snapshot",
+  title: "Visual snapshot (screenshot baseline)",
+  description: [
+    "Record a visual-regression baseline: stores a toHaveScreenshot() assertion in the trace so the generated test pixel-compares the page/element/region against a baseline image on every run (the baseline is created on the test's first run).",
+    "Use this to lock the visual appearance of a page, an element, or a screen region after a key action (e.g. a rendered chart, a styled component, a confirmation screen).",
+    "The `snapshotType` parameter selects the target:",
+    "- page: the whole page (set fullPage to capture the full scrollable page rather than just the viewport).",
+    "- element: a single element, identified by its snapshot ref. The ref is resolved to a durable selector for the generated test.",
+    "- region: a rectangular area given by clip (x, y, width, height) in viewport pixels, read from a normal (non-fullPage) screenshot.",
+    "This complements browser_assert (which checks text/value/state): use browser_visual_snapshot when the thing to verify is how it LOOKS, not its text."
+  ].join(" "),
+  inputSchema: import_mcpBundle.z.object({
+    snapshotType: import_mcpBundle.z.enum(["page", "element", "region"]).describe("What to capture: whole page, a single element (by ref), or a pixel region (by clip)."),
+    ref: import_mcpBundle.z.string().optional().describe('Element snapshot ref to capture. Required for snapshotType "element".'),
+    element: import_mcpBundle.z.string().optional().describe("Human-readable description of the element (paired with ref) for permission and logging."),
+    fullPage: import_mcpBundle.z.boolean().optional().describe('For snapshotType "page": capture the full scrollable page instead of just the viewport.'),
+    clip: import_mcpBundle.z.object({
+      x: import_mcpBundle.z.number().describe("Left edge, in viewport pixels (distance from the visible top-left, not the document top)."),
+      y: import_mcpBundle.z.number().describe("Top edge, in viewport pixels (distance from the visible top-left, not the document top)."),
+      width: import_mcpBundle.z.number().positive().describe("Region width in pixels."),
+      height: import_mcpBundle.z.number().positive().describe("Region height in pixels.")
+    }).optional().describe('For snapshotType "region": the rectangle to capture, in VIEWPORT pixels. Read these coordinates from a normal (viewport) browser_take_screenshot, NOT a fullPage one \u2014 the region is clipped to the visible viewport, so document/scrolled coordinates will be off.'),
+    filename: import_mcpBundle.z.string().optional().describe("Baseline filename. Auto-generated (page-NNN.png / el-NNN.png / region-NNN.png) when omitted.")
+  }),
+  // Marker-only: records a trace marker, does not mutate the page. Mirrors the
+  // other marker tools (browser_assert, browser_assert_api_request).
+  type: "readOnly"
+};
+function visualSnapshotMcpTool() {
+  return (0, import_tool.toMcpTool)(visualSnapshotSchema);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  visualSnapshotMcpTool,
+  visualSnapshotSchema
+});

package/node_modules/playwright/lib/mcp/test/skyRampExport.js

@@ -227,6 +227,11 @@ function trackedActionToJsonl(action, pageGuid, timestamp) {
   }
   if (toolName === "browser_press_key")
     return JSON.stringify({ name: "press", key: args.key, modifiers: modifiersArrayToMask(args.modifiers), selector: "", ...base });
+  if (toolName === "browser_mouse_action") {
+    if (!args.name)
+      return null;
+    return JSON.stringify({ ...args, ...base });
+  }
   if (!code)
     return null;
   const extracted = extractLocatorFromCode(code);
@@ -347,6 +352,32 @@ function assertActionToJsonl(action, pageGuid, timestamp) {
       return null;
   }
 }
+function visualSnapshotActionToJsonl(action, pageGuid, timestamp) {
+  const args = action.args;
+  if (!args || !args.filename || !String(args.filename).toLowerCase().endsWith(".png"))
+    return null;
+  const base = {
+    signals: [],
+    timestamp: String(timestamp),
+    pageGuid,
+    pageAlias: action.pageAlias ?? DEFAULT_PAGE_ALIAS,
+    framePath: action.framePath ?? DEFAULT_FRAME_PATH
+  };
+  if (args.snapshotType === "page")
+    return JSON.stringify({ name: "visualSnapshot", snapshotType: "page", filename: args.filename, ...args.fullPage ? { fullPage: true } : {}, ...args.screenshotStyle ? { screenshotStyle: args.screenshotStyle } : {}, ...base });
+  if (args.snapshotType === "element") {
+    if (!args.selector)
+      return null;
+    return JSON.stringify({ name: "visualSnapshot", snapshotType: "element", filename: args.filename, selector: args.selector, ...base });
+  }
+  if (args.snapshotType === "region") {
+    const c = args.clip;
+    if (!c || c.x === void 0 || c.y === void 0 || c.width === void 0 || c.height === void 0)
+      return null;
+    return JSON.stringify({ name: "visualSnapshot", snapshotType: "region", filename: args.filename, clip: { x: c.x, y: c.y, width: c.width, height: c.height }, ...base });
+  }
+  return null;
+}
 function selectorToLocator(selector) {
   const testidMatch = selector.match(/internal:testid=\[data-testid="([^"]+)"/);
   if (testidMatch)
@@ -513,6 +544,16 @@ function buildJsonlContent(actions, browserName, harPath) {
       actionCount++;
       continue;
     }
+    if (action.toolName === "browser_visual_snapshot") {
+      const vsLine = visualSnapshotActionToJsonl(action, pageGuid, action.timestamp);
+      if (vsLine) {
+        lines.push(vsLine);
+        actionCount++;
+      } else {
+        skipped.push(action.toolName);
+      }
+      continue;
+    }
     if ((action.toolName === "browser_type" || action.toolName === "browser_press_sequentially") && action.args.submit) {
       const fillLine = trackedActionToJsonl(action, pageGuid, action.timestamp);
       if (fillLine) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyramp/mcp",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "main": "build/index.js",
   "exports": {
     ".": "./build/index.js",