@ufira/vibma 0.2.1 → 0.3.0

package/dist/mcp.cjs

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -25,30 +22,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/utils/color.ts
-var init_color = __esm({
-  "src/utils/color.ts"() {
-  }
-});
-
-// src/utils/serialize-node.ts
-var init_serialize_node = __esm({
-  "src/utils/serialize-node.ts"() {
-    init_color();
-  }
-});
-
 // src/mcp.ts
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_zod19 = require("zod");
+var import_zod18 = require("zod");
 var import_ws = __toESM(require("ws"), 1);
 var import_uuid = require("uuid");
 var import_fs = require("fs");
 var import_path = require("path");
-
-// src/tools/document.ts
-var import_zod = require("zod");
+var import_url = require("url");
 
 // src/tools/types.ts
 var MAX_RESPONSE_CHARS = 5e4;
@@ -73,89 +55,80 @@ function mcpError(prefix, error) {
   return { content: [{ type: "text", text: `${prefix}: ${msg}` }] };
 }
 
-// src/tools/document.ts
-function registerMcpTools(server2, sendCommand) {
-  server2.tool(
-    "get_document_info",
-    "Get the document name, current page, and list of all pages.",
-    {},
-    async () => {
-      try {
-        return mcpJson(await sendCommand("get_document_info"));
-      } catch (e) {
-        return mcpError("Error getting document info", e);
-      }
-    }
-  );
-  server2.tool(
-    "get_current_page",
-    "Get the current page info and its top-level children. Always safe \u2014 never touches unloaded pages.",
-    {},
-    async () => {
+// src/tools/registry.ts
+function registerTools(server2, sendCommand, caps2, tools16) {
+  for (const tool of tools16) {
+    if (tool.tier === "create" && !caps2.create) continue;
+    if (tool.tier === "edit" && !caps2.edit) continue;
+    const schema = typeof tool.schema === "function" ? tool.schema(caps2) : tool.schema;
+    const command = tool.command ?? tool.name;
+    const timeout = tool.timeout;
+    const format = tool.formatResponse ?? mcpJson;
+    server2.registerTool(tool.name, { description: tool.description, inputSchema: schema }, async (params) => {
       try {
-        return mcpJson(await sendCommand("get_current_page"));
+        if (tool.validate) tool.validate(params);
+        const result = await sendCommand(command, params, timeout);
+        return format(result);
       } catch (e) {
-        return mcpError("Error getting current page", e);
+        return mcpError(`${tool.name} error`, e);
       }
-    }
-  );
-  server2.tool(
-    "get_pages",
-    "Get all pages in the document with their IDs, names, and child counts.",
-    {},
-    async () => {
-      try {
-        return mcpJson(await sendCommand("get_pages"));
-      } catch (e) {
-        return mcpError("Error getting pages", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_current_page",
-    "Switch to a different page. Provide either pageId or pageName.",
-    {
+    });
+  }
+}
+
+// src/tools/defs/connection.ts
+var tools = [
+  {
+    name: "ping",
+    description: "Verify end-to-end connection to Figma. Call this right after join_channel. Returns { status: 'pong', documentName, currentPage } if the full chain (MCP \u2192 relay \u2192 plugin \u2192 Figma) is working. If this times out, the Figma plugin is not connected \u2014 ask the user to check the plugin window for the correct port and channel name.",
+    schema: {},
+    tier: "read",
+    timeout: 5e3
+  }
+];
+
+// src/tools/defs/document.ts
+var import_zod = require("zod");
+var tools2 = [
+  {
+    name: "get_document_info",
+    description: "Get the document name, current page, and list of all pages.",
+    schema: {},
+    tier: "read"
+  },
+  {
+    name: "get_current_page",
+    description: "Get the current page info and its top-level children.",
+    schema: {},
+    tier: "read"
+  },
+  {
+    name: "set_current_page",
+    description: "Switch to a different page. Provide either pageId or pageName.",
+    schema: {
       pageId: import_zod.z.string().optional().describe("The page ID to switch to"),
       pageName: import_zod.z.string().optional().describe("The page name (case-insensitive, partial match)")
     },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_current_page", params));
-      } catch (e) {
-        return mcpError("Error setting current page", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_page",
-    "Create a new page in the document",
-    { name: import_zod.z.string().optional().describe("Name for the new page (default: 'New Page')") },
-    async ({ name }) => {
-      try {
-        return mcpJson(await sendCommand("create_page", { name }));
-      } catch (e) {
-        return mcpError("Error creating page", e);
-      }
-    }
-  );
-  server2.tool(
-    "rename_page",
-    "Rename a page. Defaults to current page if no pageId given.",
-    {
+    tier: "read"
+  },
+  {
+    name: "create_page",
+    description: "Create a new page in the document",
+    schema: { name: import_zod.z.string().optional().describe("Name for the new page (default: 'New Page')") },
+    tier: "create"
+  },
+  {
+    name: "rename_page",
+    description: "Rename a page. Defaults to current page if no pageId given.",
+    schema: {
       newName: import_zod.z.string().describe("New name for the page"),
       pageId: import_zod.z.string().optional().describe("Page ID (default: current page)")
     },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("rename_page", params));
-      } catch (e) {
-        return mcpError("Error renaming page", e);
-      }
-    }
-  );
-}
+    tier: "edit"
+  }
+];
 
-// src/tools/selection.ts
+// src/tools/defs/selection.ts
 var import_zod3 = require("zod");
 
 // src/utils/coercion.ts
@@ -183,114 +156,41 @@ var flexNum = (inner) => import_zod2.z.preprocess((v) => {
   return v;
 }, inner);
 
-// src/tools/selection.ts
-function registerMcpTools2(server2, sendCommand) {
-  server2.tool(
-    "get_selection",
-    "Get information about the current selection in Figma",
-    {},
-    async () => {
-      try {
-        return mcpJson(await sendCommand("get_selection"));
-      } catch (e) {
-        return mcpError("Error getting selection", e);
-      }
-    }
-  );
-  server2.tool(
-    "read_my_design",
-    "Read the nodes the user has selected in Figma (or set via set_selection). Returns nothing if no selection exists \u2014 ask the user to select something, or use get_node_info with specific node IDs. Use depth to control child traversal.",
-    { depth: import_zod3.z.coerce.number().optional().describe("Levels of children to recurse. 0=selection only, -1 or omit for unlimited.") },
-    async ({ depth: depth2 }) => {
-      try {
-        return mcpJson(await sendCommand("read_my_design", { depth: depth2 }));
-      } catch (e) {
-        return mcpError("Error reading design", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_selection",
-    "Set selection to nodes and scroll viewport to show them. Also works as focus (single node).",
-    {
+// src/tools/defs/selection.ts
+var tools3 = [
+  {
+    name: "get_selection",
+    description: "Get the current selection. Without depth, returns stubs (id/name/type). With depth, returns full serialized node trees.",
+    schema: { depth: import_zod3.z.coerce.number().optional().describe("Child recursion depth. Omit for stubs only, 0=selected nodes' properties, -1=unlimited.") },
+    tier: "read"
+  },
+  {
+    name: "set_selection",
+    description: "Set selection to nodes and scroll viewport to show them. Also works as focus (single node).",
+    schema: {
       nodeIds: flexJson(import_zod3.z.array(import_zod3.z.string())).describe('Array of node IDs to select. Example: ["1:2","1:3"]')
     },
-    async ({ nodeIds: nodeIds2 }) => {
-      try {
-        return mcpJson(await sendCommand("set_selection", { nodeIds: nodeIds2 }));
-      } catch (e) {
-        return mcpError("Error setting selection", e);
-      }
-    }
-  );
-  server2.tool(
-    "zoom_into_view",
-    "Zoom the viewport to fit specific nodes (like pressing Shift+1)",
-    {
-      nodeIds: flexJson(import_zod3.z.array(import_zod3.z.string())).describe("Array of node IDs to zoom into")
-    },
-    async ({ nodeIds: nodeIds2 }) => {
-      try {
-        return mcpJson(await sendCommand("zoom_into_view", { nodeIds: nodeIds2 }));
-      } catch (e) {
-        return mcpError("Error zooming", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_viewport",
-    "Set viewport center position and/or zoom level",
-    {
-      center: flexJson(import_zod3.z.object({ x: import_zod3.z.coerce.number(), y: import_zod3.z.coerce.number() })).optional().describe("Viewport center point. Omit to keep current center."),
-      zoom: import_zod3.z.coerce.number().optional().describe("Zoom level (1 = 100%). Omit to keep current zoom.")
-    },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_viewport", params));
-      } catch (e) {
-        return mcpError("Error setting viewport", e);
-      }
-    }
-  );
-}
+    tier: "read"
+  }
+];
 
-// src/tools/node-info.ts
+// src/tools/defs/node-info.ts
 var import_zod4 = require("zod");
-init_serialize_node();
-function registerMcpTools3(server2, sendCommand) {
-  server2.tool(
-    "get_node_info",
-    "Get detailed information about one or more nodes. Always pass an array of IDs. Use `fields` to select only the properties you need (reduces context size).",
-    {
+var tools4 = [
+  {
+    name: "get_node_info",
+    description: "Get detailed information about one or more nodes. Always pass an array of IDs. Use `fields` to select only the properties you need (reduces context size).",
+    schema: {
       nodeIds: flexJson(import_zod4.z.array(import_zod4.z.string())).describe('Array of node IDs. Example: ["1:2","1:3"]'),
       depth: import_zod4.z.coerce.number().optional().describe("Child recursion depth (default: unlimited). 0=stubs only."),
-      fields: flexJson(import_zod4.z.array(import_zod4.z.string())).optional().describe('Whitelist of property names to include. Always includes id, name, type. Example: ["absoluteBoundingBox","layoutMode","fills"]. Omit to return all properties.')
+      fields: flexJson(import_zod4.z.array(import_zod4.z.string())).optional().describe('Whitelist of property names to include. Example: ["absoluteBoundingBox","layoutMode","fills"]. Omit to return all properties.')
     },
-    async (params) => {
-      try {
-        const result = await sendCommand("get_node_info", params);
-        return mcpJson(result);
-      } catch (e) {
-        return mcpError("Error getting node info", e);
-      }
-    }
-  );
-  server2.tool(
-    "get_node_css",
-    "Get CSS properties for a node (useful for dev handoff)",
-    { nodeId: import_zod4.z.string().describe("The node ID to get CSS for") },
-    async ({ nodeId: nodeId2 }) => {
-      try {
-        return mcpJson(await sendCommand("get_node_css", { nodeId: nodeId2 }));
-      } catch (e) {
-        return mcpError("Error getting CSS", e);
-      }
-    }
-  );
-  server2.tool(
-    "search_nodes",
-    "Search for nodes by layer name and/or type. Searches current page only \u2014 use set_current_page to switch pages first. Matches layer names (text nodes are often auto-named from their content). Returns paginated results.",
-    {
+    tier: "read"
+  },
+  {
+    name: "search_nodes",
+    description: "Search nodes on the current page by name and/or type. Use set_current_page first to search other pages. Paginated (default 50).",
+    schema: {
       query: import_zod4.z.string().optional().describe("Name search (case-insensitive substring). Omit to match all names."),
       types: flexJson(import_zod4.z.array(import_zod4.z.string())).optional().describe('Filter by types. Example: ["FRAME","TEXT"]. Omit to match all types.'),
       scopeNodeId: import_zod4.z.string().optional().describe("Node ID to search within (defaults to current page)"),
@@ -298,36 +198,27 @@ function registerMcpTools3(server2, sendCommand) {
       limit: import_zod4.z.coerce.number().optional().describe("Max results (default 50)"),
       offset: import_zod4.z.coerce.number().optional().describe("Skip N results for pagination (default 0)")
     },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("search_nodes", params));
-      } catch (e) {
-        return mcpError("Error searching nodes", e);
-      }
-    }
-  );
-  server2.tool(
-    "export_node_as_image",
-    "Export a node as an image from Figma",
-    {
+    tier: "read"
+  },
+  {
+    name: "export_node_as_image",
+    description: "Export a node as an image from Figma",
+    schema: {
       nodeId: import_zod4.z.string().describe("The node ID to export"),
       format: import_zod4.z.enum(["PNG", "JPG", "SVG", "PDF"]).optional().describe("Export format (default: PNG)"),
       scale: import_zod4.z.coerce.number().positive().optional().describe("Export scale (default: 1)")
     },
-    async ({ nodeId: nodeId2, format, scale }) => {
-      try {
-        const result = await sendCommand("export_node_as_image", { nodeId: nodeId2, format, scale });
-        return {
-          content: [{ type: "image", data: result.imageData, mimeType: result.mimeType || "image/png" }]
-        };
-      } catch (e) {
-        return mcpError("Error exporting image", e);
-      }
+    tier: "read",
+    formatResponse: (result) => {
+      const r = result;
+      return {
+        content: [{ type: "image", data: r.imageData, mimeType: r.mimeType || "image/png" }]
+      };
     }
-  );
-}
+  }
+];
 
-// src/tools/create-shape.ts
+// src/tools/defs/create-shape.ts
 var import_zod6 = require("zod");
 
 // src/tools/schemas.ts
@@ -359,7 +250,7 @@ var colorRgba = import_zod5.z.preprocess((v) => {
   g: import_zod5.z.coerce.number().min(0).max(1),
   b: import_zod5.z.coerce.number().min(0).max(1),
   a: import_zod5.z.coerce.number().min(0).max(1).optional()
-}));
+})).describe('Hex "#FF0000" or {r,g,b,a?} with values 0-1.');
 var effectEntry = import_zod5.z.object({
   type: import_zod5.z.enum(["DROP_SHADOW", "INNER_SHADOW", "LAYER_BLUR", "BACKGROUND_BLUR"]),
   color: flexJson(colorRgba).optional(),
@@ -370,34 +261,7 @@ var effectEntry = import_zod5.z.object({
   blendMode: import_zod5.z.string().optional()
 });
 
-// src/tools/helpers.ts
-init_serialize_node();
-
-// src/tools/create-shape.ts
-var rectItem = import_zod6.z.object({
-  name: import_zod6.z.string().optional().describe("Name (default: 'Rectangle')"),
-  x: xPos,
-  y: yPos,
-  width: import_zod6.z.coerce.number().optional().describe("Width (default: 100)"),
-  height: import_zod6.z.coerce.number().optional().describe("Height (default: 100)"),
-  parentId
-});
-var ellipseItem = import_zod6.z.object({
-  name: import_zod6.z.string().optional().describe("Layer name (default: 'Ellipse')"),
-  x: xPos,
-  y: yPos,
-  width: import_zod6.z.coerce.number().optional().describe("Width (default: 100)"),
-  height: import_zod6.z.coerce.number().optional().describe("Height (default: 100)"),
-  parentId
-});
-var lineItem = import_zod6.z.object({
-  name: import_zod6.z.string().optional().describe("Layer name (default: 'Line')"),
-  x: xPos,
-  y: yPos,
-  length: import_zod6.z.coerce.number().optional().describe("Length (default: 100)"),
-  rotation: import_zod6.z.coerce.number().optional().describe("Rotation in degrees (default: 0)"),
-  parentId
-});
+// src/tools/defs/create-shape.ts
 var sectionItem = import_zod6.z.object({
   name: import_zod6.z.string().optional().describe("Name (default: 'Section')"),
   x: xPos,
@@ -413,87 +277,22 @@ var svgItem = import_zod6.z.object({
   y: yPos,
   parentId
 });
-var boolOpItem = import_zod6.z.object({
-  nodeIds: flexJson(import_zod6.z.array(import_zod6.z.string())).describe("Array of node IDs (min 2)"),
-  operation: import_zod6.z.enum(["UNION", "INTERSECT", "SUBTRACT", "EXCLUDE"]).describe("Boolean operation type"),
-  name: import_zod6.z.string().optional().describe("Name for the result. Omit to auto-generate.")
-});
-function registerMcpTools4(server2, sendCommand) {
-  server2.tool(
-    "create_rectangle",
-    "Create rectangles (leaf nodes \u2014 cannot have children). For containers/cards/panels, use create_frame instead. Batch: pass multiple items.",
-    { items: flexJson(import_zod6.z.array(rectItem)).describe("Array of rectangles to create"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_rectangle", params));
-      } catch (e) {
-        return mcpError("Error creating rectangles", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_ellipse",
-    "Create ellipses (leaf nodes \u2014 cannot have children). For circular containers, use create_frame with cornerRadius instead. Batch: pass multiple items.",
-    { items: flexJson(import_zod6.z.array(ellipseItem)).describe("Array of ellipses to create"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_ellipse", params));
-      } catch (e) {
-        return mcpError("Error creating ellipses", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_line",
-    "Create lines (leaf nodes \u2014 cannot have children). For dividers inside layouts, use create_frame with a thin height and fill color instead. Batch: pass multiple items.",
-    { items: flexJson(import_zod6.z.array(lineItem)).describe("Array of lines to create"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_line", params));
-      } catch (e) {
-        return mcpError("Error creating lines", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_section",
-    "Create section nodes to organize content on the canvas.",
-    { items: flexJson(import_zod6.z.array(sectionItem)).describe("Array of sections to create"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_section", params));
-      } catch (e) {
-        return mcpError("Error creating sections", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_node_from_svg",
-    "Create nodes from SVG strings.",
-    { items: flexJson(import_zod6.z.array(svgItem)).describe("Array of SVG items to create"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_node_from_svg", params));
-      } catch (e) {
-        return mcpError("Error creating SVG nodes", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_boolean_operation",
-    "Create a boolean operation (union, intersect, subtract, exclude) from multiple nodes.",
-    { items: flexJson(import_zod6.z.array(boolOpItem)).describe("Array of boolean operations to create"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_boolean_operation", params));
-      } catch (e) {
-        return mcpError("Error creating boolean operations", e);
-      }
-    }
-  );
-}
+var tools5 = [
+  {
+    name: "create_section",
+    description: "Create section nodes to organize content on the canvas.",
+    schema: { items: flexJson(import_zod6.z.array(sectionItem)).describe("Array of sections to create"), depth },
+    tier: "create"
+  },
+  {
+    name: "create_node_from_svg",
+    description: "Create nodes from SVG strings.",
+    schema: { items: flexJson(import_zod6.z.array(svgItem)).describe("Array of SVG items to create"), depth },
+    tier: "create"
+  }
+];
 
-// src/tools/create-frame.ts
+// src/tools/defs/create-frame.ts
 var import_zod7 = require("zod");
 var frameItem = import_zod7.z.object({
   name: import_zod7.z.string().optional().describe("Frame name (default: 'Frame')"),
@@ -502,8 +301,8 @@ var frameItem = import_zod7.z.object({
   width: import_zod7.z.coerce.number().optional().describe("Width (default: 100)"),
   height: import_zod7.z.coerce.number().optional().describe("Height (default: 100)"),
   parentId,
-  fillColor: flexJson(colorRgba).optional().describe('Fill color. Hex "#FF0000" or {r,g,b,a?} 0-1. Default: no fill (empty fills array).'),
-  strokeColor: flexJson(colorRgba).optional().describe('Stroke color. Hex "#FF0000" or {r,g,b,a?} 0-1. Default: none.'),
+  fillColor: flexJson(colorRgba).optional().describe("Fill color. Default: no fill."),
+  strokeColor: flexJson(colorRgba).optional().describe("Stroke color. Default: none."),
   strokeWeight: import_zod7.z.coerce.number().positive().optional().describe("Stroke weight (default: 1)"),
   cornerRadius: import_zod7.z.coerce.number().min(0).optional().describe("Corner radius (default: 0)"),
   layoutMode: import_zod7.z.enum(["NONE", "HORIZONTAL", "VERTICAL"]).optional().describe("Auto-layout direction (default: NONE)"),
@@ -517,7 +316,6 @@ var frameItem = import_zod7.z.object({
   layoutSizingHorizontal: import_zod7.z.enum(["FIXED", "HUG", "FILL"]).optional(),
   layoutSizingVertical: import_zod7.z.enum(["FIXED", "HUG", "FILL"]).optional(),
   itemSpacing: import_zod7.z.coerce.number().optional().describe("Spacing between children (default: 0)"),
-  // Style/variable references
   fillStyleName: import_zod7.z.string().optional().describe("Apply a fill paint style by name (case-insensitive). Omit to skip."),
   strokeStyleName: import_zod7.z.string().optional().describe("Apply a stroke paint style by name. Omit to skip."),
   fillVariableId: import_zod7.z.string().optional().describe("Bind a color variable to the fill. Creates a solid fill and binds the variable to fills/0/color."),
@@ -529,1110 +327,681 @@ var autoLayoutItem = import_zod7.z.object({
   layoutMode: import_zod7.z.enum(["HORIZONTAL", "VERTICAL"]).optional().describe("Direction (default: VERTICAL)"),
   itemSpacing: import_zod7.z.coerce.number().optional().describe("Spacing between children (default: 0)"),
   paddingTop: import_zod7.z.coerce.number().optional().describe("Top padding (default: 0)"),
-  paddingRight: import_zod7.z.coerce.number().optional().describe("Right padding (default: 0)"),
-  paddingBottom: import_zod7.z.coerce.number().optional().describe("Bottom padding (default: 0)"),
-  paddingLeft: import_zod7.z.coerce.number().optional().describe("Left padding (default: 0)"),
-  primaryAxisAlignItems: import_zod7.z.enum(["MIN", "MAX", "CENTER", "SPACE_BETWEEN"]).optional(),
-  counterAxisAlignItems: import_zod7.z.enum(["MIN", "MAX", "CENTER", "BASELINE"]).optional(),
-  layoutSizingHorizontal: import_zod7.z.enum(["FIXED", "HUG", "FILL"]).optional(),
-  layoutSizingVertical: import_zod7.z.enum(["FIXED", "HUG", "FILL"]).optional(),
-  layoutWrap: import_zod7.z.enum(["NO_WRAP", "WRAP"]).optional()
-});
-function registerMcpTools5(server2, sendCommand) {
-  server2.tool(
-    "create_frame",
-    "Create frames in Figma. Batch supported. Use fillStyleName/fillVariableId and strokeStyleName/strokeVariableId instead of hardcoded colors \u2014 hardcoded values skip design tokens and will trigger lint warnings.",
-    { items: flexJson(import_zod7.z.array(frameItem)).describe("Array of frames to create"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_frame", params));
-      } catch (e) {
-        return mcpError("Error creating frames", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_auto_layout",
-    "Wrap existing nodes in an auto-layout frame. One call replaces create_frame + update_frame + insert_child \xD7 N.",
-    { items: flexJson(import_zod7.z.array(autoLayoutItem)).describe("Array of auto-layout wraps to perform"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_auto_layout", params));
-      } catch (e) {
-        return mcpError("Error creating auto layout", e);
-      }
-    }
-  );
-}
-
-// src/tools/create-text.ts
-var import_zod8 = require("zod");
-var textItem = import_zod8.z.object({
-  text: import_zod8.z.string().describe("Text content"),
-  name: import_zod8.z.string().optional().describe("Layer name (default: text content)"),
-  x: xPos,
-  y: yPos,
-  fontFamily: import_zod8.z.string().optional().describe("Font family (default: Inter). Use get_available_fonts to list installed fonts."),
-  fontStyle: import_zod8.z.string().optional().describe("Font style, e.g. 'Regular', 'Bold', 'Italic' (default: derived from fontWeight). Overrides fontWeight when set."),
-  fontSize: import_zod8.z.coerce.number().optional().describe("Font size (default: 14)"),
-  fontWeight: import_zod8.z.coerce.number().optional().describe("Font weight: 100-900 (default: 400). Ignored when fontStyle is set."),
-  fontColor: flexJson(colorRgba).optional().describe('Font color. Hex "#000000" or {r,g,b,a?} 0-1. Default: black.'),
-  fontColorVariableId: import_zod8.z.string().optional().describe("Bind a color variable to the text fill instead of hardcoded fontColor."),
-  fontColorStyleName: import_zod8.z.string().optional().describe("Apply a paint style to the text fill by name (case-insensitive). Overrides fontColor."),
-  parentId,
-  textStyleId: import_zod8.z.string().optional().describe("Text style ID to apply (overrides fontSize/fontWeight). Omit to skip."),
-  textStyleName: import_zod8.z.string().optional().describe("Text style name (case-insensitive match). Omit to skip."),
-  textAlignHorizontal: import_zod8.z.enum(["LEFT", "CENTER", "RIGHT", "JUSTIFIED"]).optional().describe("Horizontal text alignment (default: LEFT)"),
-  textAlignVertical: import_zod8.z.enum(["TOP", "CENTER", "BOTTOM"]).optional().describe("Vertical text alignment (default: TOP)"),
-  layoutSizingHorizontal: import_zod8.z.enum(["FIXED", "HUG", "FILL"]).optional().describe("Horizontal sizing. FILL auto-sets textAutoResize to HEIGHT."),
-  layoutSizingVertical: import_zod8.z.enum(["FIXED", "HUG", "FILL"]).optional().describe("Vertical sizing (default: HUG)"),
-  textAutoResize: import_zod8.z.enum(["NONE", "WIDTH_AND_HEIGHT", "HEIGHT", "TRUNCATE"]).optional().describe("Text auto-resize behavior (default: WIDTH_AND_HEIGHT when FILL)")
-});
-function registerMcpTools6(server2, sendCommand) {
-  server2.tool(
-    "create_text",
-    "Create text nodes. Max 10 per batch. Prefer textStyleName for typography and fontColorStyleName or fontColorVariableId for color \u2014 hardcoded values skip design tokens. Supports custom fonts via fontFamily.",
-    { items: flexJson(import_zod8.z.array(textItem).max(10)).describe("Array of text nodes to create (max 10)"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_text", params));
-      } catch (e) {
-        return mcpError("Error creating text", e);
-      }
-    }
-  );
-}
-
-// src/tools/modify-node.ts
-var import_zod9 = require("zod");
-var moveItem = import_zod9.z.object({
-  nodeId,
-  x: import_zod9.z.coerce.number().describe("New X"),
-  y: import_zod9.z.coerce.number().describe("New Y")
-});
-var resizeItem = import_zod9.z.object({
-  nodeId,
-  width: import_zod9.z.coerce.number().positive().describe("New width"),
-  height: import_zod9.z.coerce.number().positive().describe("New height")
-});
-var deleteItem = import_zod9.z.object({
-  nodeId: import_zod9.z.string().describe("Node ID to delete")
-});
-var cloneItem = import_zod9.z.object({
-  nodeId: import_zod9.z.string().describe("Node ID to clone"),
-  parentId: import_zod9.z.string().optional().describe("Parent for the clone (e.g. a page ID). Defaults to same parent as original."),
-  x: import_zod9.z.coerce.number().optional().describe("New X for clone. Omit to keep original position."),
-  y: import_zod9.z.coerce.number().optional().describe("New Y for clone. Omit to keep original position.")
-});
-var insertItem = import_zod9.z.object({
-  parentId: import_zod9.z.string().describe("Parent node ID"),
-  childId: import_zod9.z.string().describe("Child node ID to move"),
-  index: import_zod9.z.coerce.number().optional().describe("Index to insert at (0=first). Omit to append.")
-});
-function registerMcpTools7(server2, sendCommand) {
-  server2.tool(
-    "move_node",
-    "Move nodes to new positions. Batch: pass multiple items.",
-    { items: flexJson(import_zod9.z.array(moveItem)).describe("Array of {nodeId, x, y}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("move_node", params));
-      } catch (e) {
-        return mcpError("Error moving nodes", e);
-      }
-    }
-  );
-  server2.tool(
-    "resize_node",
-    "Resize nodes. Batch: pass multiple items.",
-    { items: flexJson(import_zod9.z.array(resizeItem)).describe("Array of {nodeId, width, height}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("resize_node", params));
-      } catch (e) {
-        return mcpError("Error resizing nodes", e);
-      }
-    }
-  );
-  server2.tool(
-    "delete_node",
-    "Delete nodes. Batch: pass multiple items.",
-    { items: flexJson(import_zod9.z.array(deleteItem)).describe("Array of {nodeId}") },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("delete_node", params));
-      } catch (e) {
-        return mcpError("Error deleting nodes", e);
-      }
-    }
-  );
-  server2.tool(
-    "clone_node",
-    "Clone nodes. Batch: pass multiple items.",
-    { items: flexJson(import_zod9.z.array(cloneItem)).describe("Array of {nodeId, x?, y?}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("clone_node", params));
-      } catch (e) {
-        return mcpError("Error cloning nodes", e);
-      }
-    }
-  );
-  server2.tool(
-    "insert_child",
-    "Move nodes into a parent at a specific index (reorder/reparent). Batch: pass multiple items.",
-    { items: flexJson(import_zod9.z.array(insertItem)).describe("Array of {parentId, childId, index?}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("insert_child", params));
-      } catch (e) {
-        return mcpError("Error inserting children", e);
-      }
-    }
-  );
-}
-
-// src/tools/fill-stroke.ts
-var import_zod10 = require("zod");
-var fillItem = import_zod10.z.object({
-  nodeId,
-  color: flexJson(colorRgba).optional().describe('Fill color. Hex "#FF0000" or {r,g,b,a?} 0-1. Ignored when styleName is set.'),
-  styleName: import_zod10.z.string().optional().describe("Apply fill paint style by name instead of color. Omit to use color.")
-});
-var strokeItem = import_zod10.z.object({
-  nodeId,
-  color: flexJson(colorRgba).optional().describe('Stroke color. Hex "#FF0000" or {r,g,b,a?} 0-1. Ignored when styleName is set.'),
-  strokeWeight: import_zod10.z.coerce.number().positive().optional().describe("Stroke weight (default: 1)"),
-  styleName: import_zod10.z.string().optional().describe("Apply stroke paint style by name instead of color. Omit to use color.")
-});
-var cornerItem = import_zod10.z.object({
-  nodeId,
-  radius: import_zod10.z.coerce.number().min(0).describe("Corner radius"),
-  corners: flexJson(import_zod10.z.array(flexBool(import_zod10.z.boolean())).length(4)).optional().describe("Which corners to round [topLeft, topRight, bottomRight, bottomLeft]. Default: all corners [true,true,true,true].")
-});
-var opacityItem = import_zod10.z.object({
-  nodeId,
-  opacity: import_zod10.z.coerce.number().min(0).max(1).describe("Opacity (0-1)")
-});
-function registerMcpTools8(server2, sendCommand) {
-  server2.tool(
-    "set_fill_color",
-    "Set fill color on nodes. Prefer styleName (design token) over hardcoded color \u2014 hardcoded values trigger lint warnings. Batch: pass multiple items.",
-    { items: flexJson(import_zod10.z.array(fillItem)).describe("Array of {nodeId, color?, styleName?}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_fill_color", params));
-      } catch (e) {
-        return mcpError("Error setting fill", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_stroke_color",
-    "Set stroke color on nodes. Prefer styleName (design token) over hardcoded color \u2014 hardcoded values trigger lint warnings. Batch: pass multiple items.",
-    { items: flexJson(import_zod10.z.array(strokeItem)).describe("Array of {nodeId, color?, strokeWeight?, styleName?}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_stroke_color", params));
-      } catch (e) {
-        return mcpError("Error setting stroke", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_corner_radius",
-    "Set corner radius on nodes. Batch: pass multiple items.",
-    { items: flexJson(import_zod10.z.array(cornerItem)).describe("Array of {nodeId, radius, corners?}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_corner_radius", params));
-      } catch (e) {
-        return mcpError("Error setting corner radius", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_opacity",
-    "Set opacity on nodes. Batch: pass multiple items.",
-    { items: flexJson(import_zod10.z.array(opacityItem)).describe("Array of {nodeId, opacity}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_opacity", params));
-      } catch (e) {
-        return mcpError("Error setting opacity", e);
-      }
-    }
-  );
-}
-
-// src/tools/update-frame.ts
-var import_zod11 = require("zod");
-var updateFrameItem = import_zod11.z.object({
-  nodeId,
-  layoutMode: import_zod11.z.enum(["NONE", "HORIZONTAL", "VERTICAL"]).optional().describe("Auto-layout direction"),
-  layoutWrap: import_zod11.z.enum(["NO_WRAP", "WRAP"]).optional().describe("Wrap (default: NO_WRAP)"),
-  paddingTop: import_zod11.z.coerce.number().optional().describe("Top padding"),
-  paddingRight: import_zod11.z.coerce.number().optional().describe("Right padding"),
-  paddingBottom: import_zod11.z.coerce.number().optional().describe("Bottom padding"),
-  paddingLeft: import_zod11.z.coerce.number().optional().describe("Left padding"),
-  primaryAxisAlignItems: import_zod11.z.enum(["MIN", "MAX", "CENTER", "SPACE_BETWEEN"]).optional().describe("Primary axis alignment"),
-  counterAxisAlignItems: import_zod11.z.enum(["MIN", "MAX", "CENTER", "BASELINE"]).optional().describe("Counter axis alignment"),
-  layoutSizingHorizontal: import_zod11.z.enum(["FIXED", "HUG", "FILL"]).optional().describe("Horizontal sizing (works on any node in auto-layout)"),
-  layoutSizingVertical: import_zod11.z.enum(["FIXED", "HUG", "FILL"]).optional().describe("Vertical sizing (works on any node in auto-layout)"),
-  itemSpacing: import_zod11.z.coerce.number().optional().describe("Spacing between children"),
-  counterAxisSpacing: import_zod11.z.coerce.number().optional().describe("Spacing between wrapped rows/columns (WRAP only)")
-});
-function registerMcpTools9(server2, sendCommand) {
-  server2.tool(
-    "update_frame",
-    "Update layout properties on frames. Combines layout mode, padding, alignment, sizing, and spacing in one call. Batch: pass multiple items.",
-    { items: flexJson(import_zod11.z.array(updateFrameItem)).describe("Array of {nodeId, ...layout properties}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("update_frame", params));
-      } catch (e) {
-        return mcpError("Error updating frame", e);
-      }
-    }
-  );
-}
-
-// src/tools/effects.ts
-var import_zod12 = require("zod");
-var effectItem = import_zod12.z.object({
-  nodeId,
-  effects: flexJson(import_zod12.z.array(effectEntry)).optional().describe("Array of effect objects. Ignored when effectStyleName is set."),
-  effectStyleName: import_zod12.z.string().optional().describe("Apply an effect style by name (case-insensitive). Omit to use raw effects.")
-});
-var constraintItem = import_zod12.z.object({
-  nodeId,
-  horizontal: import_zod12.z.enum(["MIN", "CENTER", "MAX", "STRETCH", "SCALE"]),
-  vertical: import_zod12.z.enum(["MIN", "CENTER", "MAX", "STRETCH", "SCALE"])
-});
-var exportSettingEntry = import_zod12.z.object({
-  format: import_zod12.z.enum(["PNG", "JPG", "SVG", "PDF"]),
-  suffix: import_zod12.z.string().optional(),
-  contentsOnly: flexBool(import_zod12.z.boolean()).optional(),
-  constraint: flexJson(import_zod12.z.object({
-    type: import_zod12.z.enum(["SCALE", "WIDTH", "HEIGHT"]),
-    value: import_zod12.z.coerce.number()
-  })).optional()
-});
-var exportSettingsItem = import_zod12.z.object({
-  nodeId,
-  settings: flexJson(import_zod12.z.array(exportSettingEntry)).describe("Export settings array")
-});
-var nodePropertiesItem = import_zod12.z.object({
-  nodeId,
-  properties: flexJson(import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown())).describe("Key-value properties to set")
-});
-function registerMcpTools10(server2, sendCommand) {
-  server2.tool(
-    "set_effects",
-    "Set effects (shadows, blurs) on nodes. Use effectStyleName to apply by name, or provide raw effects. Batch: pass multiple items.",
-    { items: flexJson(import_zod12.z.array(effectItem)).describe("Array of {nodeId, effects}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_effects", params));
-      } catch (e) {
-        return mcpError("Error setting effects", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_constraints",
-    "Set constraints on nodes. Batch: pass multiple items.",
-    { items: flexJson(import_zod12.z.array(constraintItem)).describe("Array of {nodeId, horizontal, vertical}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_constraints", params));
-      } catch (e) {
-        return mcpError("Error setting constraints", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_export_settings",
-    "Set export settings on nodes. Batch: pass multiple items.",
-    { items: flexJson(import_zod12.z.array(exportSettingsItem)).describe("Array of {nodeId, settings}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_export_settings", params));
-      } catch (e) {
-        return mcpError("Error setting export settings", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_node_properties",
-    "Set arbitrary properties on nodes. Batch: pass multiple items.",
-    { items: flexJson(import_zod12.z.array(nodePropertiesItem)).describe("Array of {nodeId, properties}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_node_properties", params));
-      } catch (e) {
-        return mcpError("Error setting node properties", e);
-      }
-    }
-  );
-}
-
-// src/tools/text.ts
-var import_zod13 = require("zod");
-var textContentItem = import_zod13.z.object({
-  nodeId: import_zod13.z.string().describe("Text node ID"),
-  text: import_zod13.z.string().describe("New text content")
-});
-var textPropsItem = import_zod13.z.object({
-  nodeId: import_zod13.z.string().describe("Text node ID"),
-  fontSize: import_zod13.z.coerce.number().optional().describe("Font size"),
-  fontWeight: import_zod13.z.coerce.number().optional().describe("Font weight: 100-900"),
-  fontColor: flexJson(colorRgba).optional().describe('Font color. Hex "#000" or {r,g,b,a?} 0-1.'),
-  textStyleId: import_zod13.z.string().optional().describe("Text style ID to apply (overrides font props)"),
-  textStyleName: import_zod13.z.string().optional().describe("Text style name (case-insensitive match)"),
-  textAlignHorizontal: import_zod13.z.enum(["LEFT", "CENTER", "RIGHT", "JUSTIFIED"]).optional().describe("Horizontal text alignment"),
-  textAlignVertical: import_zod13.z.enum(["TOP", "CENTER", "BOTTOM"]).optional().describe("Vertical text alignment"),
-  textAutoResize: import_zod13.z.enum(["NONE", "WIDTH_AND_HEIGHT", "HEIGHT", "TRUNCATE"]).optional(),
-  layoutSizingHorizontal: import_zod13.z.enum(["FIXED", "HUG", "FILL"]).optional(),
-  layoutSizingVertical: import_zod13.z.enum(["FIXED", "HUG", "FILL"]).optional()
-});
-var scanTextItem = import_zod13.z.object({
-  nodeId,
-  limit: import_zod13.z.coerce.number().optional().describe("Max text nodes to return (default: 50)"),
-  includePath: flexBool(import_zod13.z.boolean()).optional().describe("Include ancestor path strings (default: true). Set false to reduce payload."),
-  includeGeometry: flexBool(import_zod13.z.boolean()).optional().describe("Include absoluteX/absoluteY/width/height (default: true). Set false to reduce payload.")
-});
-function registerMcpTools11(server2, sendCommand) {
-  server2.tool(
-    "set_text_content",
-    "Set text content on text nodes. Batch: pass multiple items to replace text in multiple nodes at once.",
-    { items: flexJson(import_zod13.z.array(textContentItem)).describe("Array of {nodeId, text}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_text_content", params));
-      } catch (e) {
-        return mcpError("Error setting text content", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_text_properties",
-    "Set font properties on existing text nodes (fontSize, fontWeight, fontColor, textStyle). Batch: pass multiple items.",
-    { items: flexJson(import_zod13.z.array(textPropsItem)).describe("Array of {nodeId, fontSize?, fontWeight?, fontColor?, ...}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_text_properties", params));
-      } catch (e) {
-        return mcpError("Error setting text properties", e);
-      }
-    }
-  );
-  server2.tool(
-    "scan_text_nodes",
-    "Scan all text nodes within a node tree. Batch: pass multiple items.",
-    { items: flexJson(import_zod13.z.array(scanTextItem)).describe("Array of {nodeId}") },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("scan_text_nodes", params));
-      } catch (e) {
-        return mcpError("Error scanning text nodes", e);
-      }
-    }
-  );
-}
-
-// src/tools/fonts.ts
-var import_zod14 = require("zod");
-function registerMcpTools12(server2, sendCommand) {
-  server2.tool(
-    "get_available_fonts",
-    "Get available fonts in Figma. Optionally filter by query string.",
-    { query: import_zod14.z.string().optional().describe("Filter fonts by name (case-insensitive). Omit to list all fonts.") },
-    async ({ query }) => {
-      try {
-        return mcpJson(await sendCommand("get_available_fonts", { query }));
-      } catch (e) {
-        return mcpError("Error getting fonts", e);
-      }
-    }
-  );
-}
-
-// src/tools/components.ts
-var import_zod15 = require("zod");
-var componentItem = import_zod15.z.object({
-  name: import_zod15.z.string().describe("Component name"),
-  x: xPos,
-  y: yPos,
-  width: import_zod15.z.coerce.number().optional().describe("Width (default: 100)"),
-  height: import_zod15.z.coerce.number().optional().describe("Height (default: 100)"),
-  parentId,
-  fillColor: flexJson(colorRgba).optional().describe('Fill color. Hex "#FF0000" or {r,g,b,a?} 0-1. Omit for no fill.'),
-  fillStyleName: import_zod15.z.string().optional().describe("Apply a fill paint style by name (case-insensitive)."),
-  fillVariableId: import_zod15.z.string().optional().describe("Bind a color variable to the fill."),
-  strokeColor: flexJson(colorRgba).optional().describe('Stroke color. Hex "#FF0000" or {r,g,b,a?} 0-1. Omit for no stroke.'),
-  strokeStyleName: import_zod15.z.string().optional().describe("Apply a stroke paint style by name."),
-  strokeVariableId: import_zod15.z.string().optional().describe("Bind a color variable to the stroke."),
-  strokeWeight: import_zod15.z.coerce.number().positive().optional().describe("Stroke weight (default: 1)"),
-  cornerRadius: import_zod15.z.coerce.number().optional().describe("Corner radius (default: 0)"),
-  layoutMode: import_zod15.z.enum(["NONE", "HORIZONTAL", "VERTICAL"]).optional().describe("Layout direction (default: NONE)"),
-  layoutWrap: import_zod15.z.enum(["NO_WRAP", "WRAP"]).optional().describe("Wrap behavior (default: NO_WRAP)"),
-  paddingTop: import_zod15.z.coerce.number().optional().describe("Top padding (default: 0)"),
-  paddingRight: import_zod15.z.coerce.number().optional().describe("Right padding (default: 0)"),
-  paddingBottom: import_zod15.z.coerce.number().optional().describe("Bottom padding (default: 0)"),
-  paddingLeft: import_zod15.z.coerce.number().optional().describe("Left padding (default: 0)"),
-  primaryAxisAlignItems: import_zod15.z.enum(["MIN", "MAX", "CENTER", "SPACE_BETWEEN"]).optional().describe("Primary axis alignment (default: MIN)"),
-  counterAxisAlignItems: import_zod15.z.enum(["MIN", "MAX", "CENTER", "BASELINE"]).optional().describe("Counter axis alignment (default: MIN)"),
-  layoutSizingHorizontal: import_zod15.z.enum(["FIXED", "HUG", "FILL"]).optional().describe("Horizontal sizing (default: FIXED)"),
-  layoutSizingVertical: import_zod15.z.enum(["FIXED", "HUG", "FILL"]).optional().describe("Vertical sizing (default: FIXED)"),
-  itemSpacing: import_zod15.z.coerce.number().optional().describe("Spacing between children (default: 0)")
-});
-var fromNodeItem = import_zod15.z.object({
-  nodeId
-});
-var combineItem = import_zod15.z.object({
-  componentIds: flexJson(import_zod15.z.array(import_zod15.z.string())).describe("Component IDs to combine (min 2)"),
-  name: import_zod15.z.string().optional().describe("Name for the component set. Omit to auto-generate.")
-});
-var propItem = import_zod15.z.object({
-  componentId: import_zod15.z.string().describe("Component node ID"),
-  propertyName: import_zod15.z.string().describe("Property name"),
-  type: import_zod15.z.enum(["BOOLEAN", "TEXT", "INSTANCE_SWAP", "VARIANT"]).describe("Property type"),
-  defaultValue: flexBool(import_zod15.z.union([import_zod15.z.string(), import_zod15.z.boolean()])).describe("Default value (string for TEXT/VARIANT, boolean for BOOLEAN)"),
-  preferredValues: flexJson(import_zod15.z.array(import_zod15.z.object({
-    type: import_zod15.z.enum(["COMPONENT", "COMPONENT_SET"]),
-    key: import_zod15.z.string()
-  })).optional()).describe("Preferred values for INSTANCE_SWAP type. Omit for none.")
-});
-var instanceItem = import_zod15.z.object({
-  componentId: import_zod15.z.string().describe("Component or component set ID"),
-  variantProperties: flexJson(import_zod15.z.record(import_zod15.z.string(), import_zod15.z.string())).optional().describe('Pick variant by properties, e.g. {"Style":"Secondary","Size":"Large"}. Ignored for plain COMPONENT IDs.'),
-  x: import_zod15.z.coerce.number().optional().describe("X position. Omit to keep default."),
-  y: import_zod15.z.coerce.number().optional().describe("Y position. Omit to keep default."),
-  parentId
-});
-function registerMcpTools13(server2, sendCommand) {
-  server2.tool(
-    "create_component",
-    "Create components in Figma. Same layout params as create_frame. Name with 'Property=Value' pattern (e.g. 'Size=Small') if you plan to combine_as_variants later. Use fillStyleName/fillVariableId over hardcoded colors. After adding text children, use add_component_property to expose text as editable properties. Batch: pass multiple items.",
-    { items: flexJson(import_zod15.z.array(componentItem)).describe("Array of components to create"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_component", params));
-      } catch (e) {
-        return mcpError("Error creating component", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_component_from_node",
-    "Convert existing nodes into components. Batch: pass multiple items.",
-    { items: flexJson(import_zod15.z.array(fromNodeItem)).describe("Array of {nodeId}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_component_from_node", params));
-      } catch (e) {
-        return mcpError("Error creating component from node", e);
-      }
-    }
-  );
-  server2.tool(
-    "combine_as_variants",
-    "Combine components into variant sets. Name components with 'Property=Value' pattern (e.g. 'Style=Primary', 'Size=Large') BEFORE combining \u2014 Figma derives variant properties from component names. Avoid slashes in names. The resulting set is placed in the components' shared parent (or page root if parents differ). Batch: pass multiple items.",
-    { items: flexJson(import_zod15.z.array(combineItem)).describe("Array of {componentIds, name?}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("combine_as_variants", params));
-      } catch (e) {
-        return mcpError("Error combining variants", e);
-      }
-    }
-  );
-  server2.tool(
-    "add_component_property",
-    "Add properties to components. Batch: pass multiple items.",
-    { items: flexJson(import_zod15.z.array(propItem)).describe("Array of {componentId, propertyName, type, defaultValue, preferredValues?}") },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("add_component_property", params));
-      } catch (e) {
-        return mcpError("Error adding component property", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_instance_from_local",
-    'Create instances of local components. For COMPONENT_SET, use variantProperties to pick a specific variant (e.g. {"Style":"Secondary"}). Batch: pass multiple items.',
-    { items: flexJson(import_zod15.z.array(instanceItem)).describe("Array of {componentId, x?, y?, parentId?}") },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_instance_from_local", params));
-      } catch (e) {
-        return mcpError("Error creating instance", e);
-      }
-    }
-  );
-  server2.tool(
-    "search_components",
-    "Search local components and component sets across all pages. Returns component id, name, and which page it lives on.",
-    {
-      query: import_zod15.z.string().optional().describe("Filter by name (case-insensitive substring). Omit to list all."),
-      setsOnly: flexBool(import_zod15.z.boolean()).optional().describe("If true, return only COMPONENT_SET nodes"),
-      limit: import_zod15.z.coerce.number().optional().describe("Max results (default 100)"),
-      offset: import_zod15.z.coerce.number().optional().describe("Skip N results (default 0)")
-    },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("search_components", params));
-      } catch (e) {
-        return mcpError("Error searching components", e);
-      }
-    }
-  );
-  server2.tool(
-    "get_component_by_id",
-    "Get detailed component info including property definitions and variants.",
-    {
-      componentId: import_zod15.z.string().describe("Component node ID"),
-      includeChildren: flexBool(import_zod15.z.boolean()).optional().describe("For COMPONENT_SETs: include variant children (default false)")
-    },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("get_component_by_id", params));
-      } catch (e) {
-        return mcpError("Error getting component", e);
-      }
-    }
-  );
-  server2.tool(
-    "get_instance_overrides",
-    "Get override properties from a component instance.",
-    { nodeId: import_zod15.z.string().optional().describe("Instance node ID (uses selection if omitted)") },
-    async ({ nodeId: nodeId2 }) => {
-      try {
-        return mcpJson(await sendCommand("get_instance_overrides", { instanceNodeId: nodeId2 || null }));
-      } catch (e) {
-        return mcpError("Error getting overrides", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_instance_properties",
-    "Set component property values on instances (e.g. text, boolean, instance swap). Use get_component_by_id to discover property keys. Batch: pass multiple items.",
-    { items: flexJson(import_zod15.z.array(import_zod15.z.object({
-      nodeId,
-      properties: flexJson(import_zod15.z.record(import_zod15.z.string(), import_zod15.z.union([import_zod15.z.string(), import_zod15.z.boolean()]))).describe('Property key\u2192value map, e.g. {"Label#1:0":"Click Me"}')
-    }))).describe("Array of {nodeId, properties}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("set_instance_properties", params));
-      } catch (e) {
-        return mcpError("Error setting instance properties", e);
-      }
-    }
-  );
-}
-
-// src/tools/styles.ts
-var import_zod16 = require("zod");
-var paintStyleItem = import_zod16.z.object({
-  name: import_zod16.z.string().describe("Style name"),
-  color: flexJson(colorRgba).describe('Color. Hex "#FF0000" or {r,g,b,a?} 0-1.')
-});
-var textStyleItem = import_zod16.z.object({
-  name: import_zod16.z.string().describe("Style name"),
-  fontFamily: import_zod16.z.string().describe("Font family"),
-  fontStyle: import_zod16.z.string().optional().describe("Font style (default: Regular)"),
-  fontSize: import_zod16.z.coerce.number().describe("Font size"),
-  lineHeight: flexNum(import_zod16.z.union([
-    import_zod16.z.number(),
-    import_zod16.z.object({ value: import_zod16.z.coerce.number(), unit: import_zod16.z.enum(["PIXELS", "PERCENT", "AUTO"]) })
-  ])).optional().describe("Line height \u2014 number (px) or {value, unit}. Default: auto."),
-  letterSpacing: flexNum(import_zod16.z.union([
-    import_zod16.z.number(),
-    import_zod16.z.object({ value: import_zod16.z.coerce.number(), unit: import_zod16.z.enum(["PIXELS", "PERCENT"]) })
-  ])).optional().describe("Letter spacing \u2014 number (px) or {value, unit}. Default: 0."),
-  textCase: import_zod16.z.enum(["ORIGINAL", "UPPER", "LOWER", "TITLE"]).optional(),
-  textDecoration: import_zod16.z.enum(["NONE", "UNDERLINE", "STRIKETHROUGH"]).optional()
-});
-var effectStyleItem = import_zod16.z.object({
-  name: import_zod16.z.string().describe("Style name"),
-  effects: flexJson(import_zod16.z.array(effectEntry)).describe("Array of effects")
-});
-var updatePaintStyleItem = import_zod16.z.object({
-  id: import_zod16.z.string().describe("Style ID or name (case-insensitive match)"),
-  name: import_zod16.z.string().optional().describe("New name"),
-  color: flexJson(colorRgba).optional().describe('New color. Hex "#FF0000" or {r,g,b,a?} 0-1.')
-});
-var updateTextStyleItem = import_zod16.z.object({
-  id: import_zod16.z.string().describe("Style ID or name (case-insensitive match)"),
-  name: import_zod16.z.string().optional().describe("New name"),
-  fontFamily: import_zod16.z.string().optional().describe("Font family"),
-  fontStyle: import_zod16.z.string().optional().describe("Font style (e.g. Regular, Bold)"),
-  fontSize: import_zod16.z.coerce.number().optional().describe("Font size"),
-  lineHeight: flexNum(import_zod16.z.union([
-    import_zod16.z.number(),
-    import_zod16.z.object({ value: import_zod16.z.coerce.number(), unit: import_zod16.z.enum(["PIXELS", "PERCENT", "AUTO"]) })
-  ])).optional().describe("Line height \u2014 number (px) or {value, unit}. Default: auto."),
-  letterSpacing: flexNum(import_zod16.z.union([
-    import_zod16.z.number(),
-    import_zod16.z.object({ value: import_zod16.z.coerce.number(), unit: import_zod16.z.enum(["PIXELS", "PERCENT"]) })
-  ])).optional().describe("Letter spacing \u2014 number (px) or {value, unit}. Default: 0."),
-  textCase: import_zod16.z.enum(["ORIGINAL", "UPPER", "LOWER", "TITLE"]).optional(),
-  textDecoration: import_zod16.z.enum(["NONE", "UNDERLINE", "STRIKETHROUGH"]).optional()
-});
-var applyStyleItem = import_zod16.z.object({
-  nodeId,
-  styleId: import_zod16.z.string().optional().describe("Style ID. Provide either styleId or styleName."),
-  styleName: import_zod16.z.string().optional().describe("Style name (case-insensitive substring match). Provide either styleId or styleName."),
-  styleType: import_zod16.z.preprocess((v) => typeof v === "string" ? v.toLowerCase() : v, import_zod16.z.enum(["fill", "stroke", "text", "effect"])).describe("Type of style: fill, stroke, text, or effect (case-insensitive)")
-});
-function registerMcpTools14(server2, sendCommand) {
-  server2.tool(
-    "get_styles",
-    "List local styles (paint, text, effect, grid). Returns IDs and names only.",
-    {},
-    async () => {
-      try {
-        return mcpJson(await sendCommand("get_styles"));
-      } catch (e) {
-        return mcpError("Error getting styles", e);
-      }
-    }
-  );
-  server2.tool(
-    "get_style_by_id",
-    "Get detailed style info by ID. Returns full paint/font/effect/grid details.",
-    { styleId: import_zod16.z.string().describe("Style ID") },
-    async ({ styleId }) => {
-      try {
-        return mcpJson(await sendCommand("get_style_by_id", { styleId }));
-      } catch (e) {
-        return mcpError("Error getting style", e);
-      }
-    }
-  );
-  server2.tool(
-    "remove_style",
-    "Delete a style by ID.",
-    { styleId: import_zod16.z.string().describe("Style ID to remove") },
-    async ({ styleId }) => {
-      try {
-        return mcpJson(await sendCommand("remove_style", { styleId }));
-      } catch (e) {
-        return mcpError("Error removing style", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_paint_style",
-    "Create color/paint styles. Batch: pass multiple items.",
-    { items: flexJson(import_zod16.z.array(paintStyleItem)).describe("Array of {name, color}") },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_paint_style", params));
-      } catch (e) {
-        return mcpError("Error creating paint style", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_text_style",
-    "Create text styles. Batch: pass multiple items.",
-    { items: flexJson(import_zod16.z.array(textStyleItem)).describe("Array of text style definitions") },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_text_style", params));
-      } catch (e) {
-        return mcpError("Error creating text style", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_effect_style",
-    "Create effect styles (shadows, blurs). Batch: pass multiple items.",
-    { items: flexJson(import_zod16.z.array(effectStyleItem)).describe("Array of {name, effects}") },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("create_effect_style", params));
-      } catch (e) {
-        return mcpError("Error creating effect style", e);
-      }
-    }
-  );
-  server2.tool(
-    "apply_style_to_node",
-    "Apply a style to nodes by ID or name. Use styleName for convenience (case-insensitive). Batch: pass multiple items.",
-    { items: flexJson(import_zod16.z.array(applyStyleItem)).describe("Array of {nodeId, styleId?, styleName?, styleType}"), depth },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("apply_style_to_node", params));
-      } catch (e) {
-        return mcpError("Error applying style", e);
-      }
-    }
-  );
-  server2.tool(
-    "update_paint_style",
-    "Update paint style color/name by ID or name. Changes propagate to all nodes using the style. Batch: pass multiple items.",
-    { items: flexJson(import_zod16.z.array(updatePaintStyleItem)).describe("Array of {id, name?, color?}") },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("update_paint_style", params));
-      } catch (e) {
-        return mcpError("Error updating paint style", e);
-      }
-    }
-  );
-  server2.tool(
-    "update_text_style",
-    "Update text style properties by ID or name. Changes propagate to all nodes using the style. Batch: pass multiple items.",
-    { items: flexJson(import_zod16.z.array(updateTextStyleItem)).describe("Array of {id, name?, fontSize?, fontFamily?, ...}") },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("update_text_style", params));
-      } catch (e) {
-        return mcpError("Error updating text style", e);
-      }
-    }
-  );
-}
+  paddingRight: import_zod7.z.coerce.number().optional().describe("Right padding (default: 0)"),
+  paddingBottom: import_zod7.z.coerce.number().optional().describe("Bottom padding (default: 0)"),
+  paddingLeft: import_zod7.z.coerce.number().optional().describe("Left padding (default: 0)"),
+  primaryAxisAlignItems: import_zod7.z.enum(["MIN", "MAX", "CENTER", "SPACE_BETWEEN"]).optional(),
+  counterAxisAlignItems: import_zod7.z.enum(["MIN", "MAX", "CENTER", "BASELINE"]).optional(),
+  layoutSizingHorizontal: import_zod7.z.enum(["FIXED", "HUG", "FILL"]).optional(),
+  layoutSizingVertical: import_zod7.z.enum(["FIXED", "HUG", "FILL"]).optional(),
+  layoutWrap: import_zod7.z.enum(["NO_WRAP", "WRAP"]).optional()
+});
+var tools6 = [
+  {
+    name: "create_frame",
+    description: "Create frames in Figma. Batch supported. Use fillStyleName/fillVariableId and strokeStyleName/strokeVariableId instead of hardcoded colors \u2014 hardcoded values skip design tokens and will trigger lint warnings.",
+    schema: { items: flexJson(import_zod7.z.array(frameItem)).describe("Array of frames to create"), depth },
+    tier: "create"
+  },
+  {
+    name: "create_auto_layout",
+    description: "Wrap existing nodes in an auto-layout frame. One call replaces create_frame + update_frame + insert_child \xD7 N.",
+    schema: { items: flexJson(import_zod7.z.array(autoLayoutItem)).describe("Array of auto-layout wraps to perform"), depth },
+    tier: "create"
+  }
+];
 
-// src/tools/variables.ts
-var import_zod17 = require("zod");
-var collectionItem = import_zod17.z.object({
-  name: import_zod17.z.string().describe("Collection name")
+// src/tools/defs/create-text.ts
+var import_zod8 = require("zod");
+var textItem = import_zod8.z.object({
+  text: import_zod8.z.string().describe("Text content"),
+  name: import_zod8.z.string().optional().describe("Layer name (default: text content)"),
+  x: xPos,
+  y: yPos,
+  fontFamily: import_zod8.z.string().optional().describe("Font family (default: Inter). Use get_available_fonts to list installed fonts."),
+  fontStyle: import_zod8.z.string().optional().describe("Font style, e.g. 'Regular', 'Bold', 'Italic' (default: derived from fontWeight). Overrides fontWeight when set."),
+  fontSize: import_zod8.z.coerce.number().optional().describe("Font size (default: 14)"),
+  fontWeight: import_zod8.z.coerce.number().optional().describe("Font weight: 100-900 (default: 400). Ignored when fontStyle is set."),
+  fontColor: flexJson(colorRgba).optional().describe("Font color. Default: black."),
+  fontColorVariableId: import_zod8.z.string().optional().describe("Bind a color variable to the text fill instead of hardcoded fontColor."),
+  fontColorStyleName: import_zod8.z.string().optional().describe("Apply a paint style to the text fill by name (case-insensitive). Overrides fontColor."),
+  parentId,
+  textStyleId: import_zod8.z.string().optional().describe("Text style ID to apply (overrides fontSize/fontWeight). Omit to skip."),
+  textStyleName: import_zod8.z.string().optional().describe("Text style name (case-insensitive match). Omit to skip."),
+  textAlignHorizontal: import_zod8.z.enum(["LEFT", "CENTER", "RIGHT", "JUSTIFIED"]).optional().describe("Horizontal text alignment (default: LEFT)"),
+  textAlignVertical: import_zod8.z.enum(["TOP", "CENTER", "BOTTOM"]).optional().describe("Vertical text alignment (default: TOP)"),
+  layoutSizingHorizontal: import_zod8.z.enum(["FIXED", "HUG", "FILL"]).optional().describe("Horizontal sizing. FILL auto-sets textAutoResize to HEIGHT."),
+  layoutSizingVertical: import_zod8.z.enum(["FIXED", "HUG", "FILL"]).optional().describe("Vertical sizing (default: HUG)"),
+  textAutoResize: import_zod8.z.enum(["NONE", "WIDTH_AND_HEIGHT", "HEIGHT", "TRUNCATE"]).optional().describe("Text auto-resize behavior (default: WIDTH_AND_HEIGHT when FILL)")
 });
-var variableItem = import_zod17.z.object({
-  collectionId: import_zod17.z.string().describe("Variable collection ID"),
-  name: import_zod17.z.string().describe("Variable name"),
-  resolvedType: import_zod17.z.enum(["COLOR", "FLOAT", "STRING", "BOOLEAN"]).describe("Variable type")
+var tools7 = [
+  {
+    name: "create_text",
+    description: "Create text nodes. Max 10 per batch. Prefer textStyleName for typography and fontColorStyleName or fontColorVariableId for color \u2014 hardcoded values skip design tokens. Supports custom fonts via fontFamily.",
+    schema: { items: flexJson(import_zod8.z.array(textItem).max(10)).describe("Array of text nodes to create (max 10)"), depth },
+    tier: "create"
+  }
+];
+
+// src/tools/defs/modify-node.ts
+var import_zod9 = require("zod");
+var deleteItem = import_zod9.z.object({
+  nodeId: import_zod9.z.string().describe("Node ID to delete")
 });
-var setValueItem = import_zod17.z.object({
-  variableId: import_zod17.z.string().describe("Variable ID (use full ID from create_variable response, e.g. VariableID:1:6)"),
-  modeId: import_zod17.z.string().describe("Mode ID"),
-  value: flexJson(import_zod17.z.union([
-    import_zod17.z.number(),
-    import_zod17.z.boolean(),
-    colorRgba
-  ])).describe('Value: number, boolean, or color (hex "#RRGGBB" or {r,g,b,a?} 0-1)')
+var cloneItem = import_zod9.z.object({
+  nodeId: import_zod9.z.string().describe("Node ID to clone"),
+  parentId: import_zod9.z.string().optional().describe("Parent for the clone (e.g. a page ID). Defaults to same parent as original."),
+  x: import_zod9.z.coerce.number().optional().describe("New X for clone. Omit to keep original position."),
+  y: import_zod9.z.coerce.number().optional().describe("New Y for clone. Omit to keep original position.")
 });
-var bindingItem = import_zod17.z.object({
-  nodeId: import_zod17.z.string().describe("Node ID"),
-  field: import_zod17.z.string().describe("Property field (e.g., 'opacity', 'fills/0/color')"),
-  variableId: import_zod17.z.string().describe("Variable ID (use full ID from create_variable response, e.g. VariableID:1:6)")
+var insertItem = import_zod9.z.object({
+  parentId: import_zod9.z.string().describe("Parent node ID"),
+  childId: import_zod9.z.string().describe("Child node ID to move"),
+  index: import_zod9.z.coerce.number().optional().describe("Index to insert at (0=first). Omit to append.")
 });
-var addModeItem = import_zod17.z.object({
-  collectionId: import_zod17.z.string().describe("Collection ID"),
-  name: import_zod17.z.string().describe("Mode name")
+var tools8 = [
+  {
+    name: "delete_node",
+    description: "Delete nodes. Batch: pass multiple items.",
+    schema: { items: flexJson(import_zod9.z.array(deleteItem)).describe("Array of {nodeId}") },
+    tier: "edit"
+  },
+  {
+    name: "clone_node",
+    description: "Clone nodes. Batch: pass multiple items.",
+    schema: { items: flexJson(import_zod9.z.array(cloneItem)).describe("Array of {nodeId, x?, y?}"), depth },
+    tier: "create"
+  },
+  {
+    name: "insert_child",
+    description: "Move nodes into a parent at a specific index (reorder/reparent). Batch: pass multiple items.",
+    schema: { items: flexJson(import_zod9.z.array(insertItem)).describe("Array of {parentId, childId, index?}"), depth },
+    tier: "edit"
+  }
+];
+
+// src/tools/defs/patch-nodes.ts
+var import_zod10 = require("zod");
+var exportSettingEntry = import_zod10.z.object({
+  format: import_zod10.z.enum(["PNG", "JPG", "SVG", "PDF"]),
+  suffix: import_zod10.z.string().optional(),
+  contentsOnly: flexBool(import_zod10.z.boolean()).optional(),
+  constraint: flexJson(import_zod10.z.object({
+    type: import_zod10.z.enum(["SCALE", "WIDTH", "HEIGHT"]),
+    value: import_zod10.z.coerce.number()
+  })).optional()
 });
-var renameModeItem = import_zod17.z.object({
-  collectionId: import_zod17.z.string().describe("Collection ID"),
-  modeId: import_zod17.z.string().describe("Mode ID"),
-  name: import_zod17.z.string().describe("New name")
+var patchNodeItem = import_zod10.z.object({
+  nodeId,
+  // Geometry (flat)
+  x: import_zod10.z.coerce.number().optional().describe("X position"),
+  y: import_zod10.z.coerce.number().optional().describe("Y position"),
+  width: import_zod10.z.coerce.number().positive().optional().describe("Width (must provide height too)"),
+  height: import_zod10.z.coerce.number().positive().optional().describe("Height (must provide width too)"),
+  // Appearance (nested)
+  fill: flexJson(import_zod10.z.object({
+    color: flexJson(colorRgba).optional(),
+    styleName: import_zod10.z.string().optional().describe("Paint style name (preferred over color)")
+  })).optional().describe("Fill color or style"),
+  stroke: flexJson(import_zod10.z.object({
+    color: flexJson(colorRgba).optional(),
+    weight: import_zod10.z.coerce.number().positive().optional().describe("Stroke weight"),
+    styleName: import_zod10.z.string().optional().describe("Paint style name (preferred over color)")
+  })).optional().describe("Stroke color/weight or style"),
+  cornerRadius: flexJson(import_zod10.z.object({
+    radius: import_zod10.z.coerce.number().min(0).describe("Corner radius"),
+    corners: flexJson(import_zod10.z.array(flexBool(import_zod10.z.boolean())).length(4)).optional().describe("Which corners [topLeft, topRight, bottomRight, bottomLeft]. Default: all.")
+  })).optional().describe("Corner radius"),
+  opacity: import_zod10.z.coerce.number().min(0).max(1).optional().describe("Opacity (0-1)"),
+  effects: flexJson(import_zod10.z.object({
+    effects: flexJson(import_zod10.z.array(effectEntry)).optional().describe("Effect objects"),
+    styleName: import_zod10.z.string().optional().describe("Effect style name (preferred over raw effects)")
+  })).optional().describe("Effects or effect style"),
+  constraints: flexJson(import_zod10.z.object({
+    horizontal: import_zod10.z.enum(["MIN", "CENTER", "MAX", "STRETCH", "SCALE"]),
+    vertical: import_zod10.z.enum(["MIN", "CENTER", "MAX", "STRETCH", "SCALE"])
+  })).optional().describe("Layout constraints"),
+  exportSettings: flexJson(import_zod10.z.array(exportSettingEntry)).optional().describe("Export settings"),
+  // Layout (nested)
+  layout: flexJson(import_zod10.z.object({
+    layoutMode: import_zod10.z.enum(["NONE", "HORIZONTAL", "VERTICAL"]).optional(),
+    layoutWrap: import_zod10.z.enum(["NO_WRAP", "WRAP"]).optional(),
+    paddingTop: import_zod10.z.coerce.number().optional(),
+    paddingRight: import_zod10.z.coerce.number().optional(),
+    paddingBottom: import_zod10.z.coerce.number().optional(),
+    paddingLeft: import_zod10.z.coerce.number().optional(),
+    primaryAxisAlignItems: import_zod10.z.enum(["MIN", "MAX", "CENTER", "SPACE_BETWEEN"]).optional(),
+    counterAxisAlignItems: import_zod10.z.enum(["MIN", "MAX", "CENTER", "BASELINE"]).optional(),
+    layoutSizingHorizontal: import_zod10.z.enum(["FIXED", "HUG", "FILL"]).optional(),
+    layoutSizingVertical: import_zod10.z.enum(["FIXED", "HUG", "FILL"]).optional(),
+    itemSpacing: import_zod10.z.coerce.number().optional(),
+    counterAxisSpacing: import_zod10.z.coerce.number().optional()
+  })).optional().describe("Auto-layout properties"),
+  // Text (nested)
+  text: flexJson(import_zod10.z.object({
+    fontSize: import_zod10.z.coerce.number().optional(),
+    fontWeight: import_zod10.z.coerce.number().optional(),
+    fontColor: flexJson(colorRgba).optional(),
+    textStyleId: import_zod10.z.string().optional(),
+    textStyleName: import_zod10.z.string().optional(),
+    textAlignHorizontal: import_zod10.z.enum(["LEFT", "CENTER", "RIGHT", "JUSTIFIED"]).optional(),
+    textAlignVertical: import_zod10.z.enum(["TOP", "CENTER", "BOTTOM"]).optional(),
+    textAutoResize: import_zod10.z.enum(["NONE", "WIDTH_AND_HEIGHT", "HEIGHT", "TRUNCATE"]).optional(),
+    layoutSizingHorizontal: import_zod10.z.enum(["FIXED", "HUG", "FILL"]).optional(),
+    layoutSizingVertical: import_zod10.z.enum(["FIXED", "HUG", "FILL"]).optional()
+  })).optional().describe("Text properties (font, alignment, sizing)"),
+  // Escape hatch
+  properties: flexJson(import_zod10.z.record(import_zod10.z.string(), import_zod10.z.unknown())).optional().describe("Arbitrary key-value properties to set directly on the node")
 });
-var removeModeItem = import_zod17.z.object({
-  collectionId: import_zod17.z.string().describe("Collection ID"),
-  modeId: import_zod17.z.string().describe("Mode ID")
+var tools9 = [
+  {
+    name: "patch_nodes",
+    description: "Patch properties on nodes. Combines geometry (x/y/width/height), appearance (fill, stroke, cornerRadius, opacity, effects, constraints, exportSettings), layout (auto-layout), text (font props), and arbitrary properties in one call. Prefer styleName over hardcoded colors. Batch: pass multiple items.",
+    schema: { items: flexJson(import_zod10.z.array(patchNodeItem)).describe("Array of nodes to patch"), depth },
+    tier: "edit"
+  }
+];
+
+// src/tools/defs/text.ts
+var import_zod11 = require("zod");
+var textContentItem = import_zod11.z.object({
+  nodeId: import_zod11.z.string().describe("Text node ID"),
+  text: import_zod11.z.string().describe("New text content")
 });
-var setExplicitModeItem = import_zod17.z.object({
+var scanTextItem = import_zod11.z.object({
   nodeId,
-  collectionId: import_zod17.z.string().describe("Variable collection ID"),
-  modeId: import_zod17.z.string().describe("Mode ID to pin (e.g. Dark mode)")
+  limit: import_zod11.z.coerce.number().optional().describe("Max text nodes to return (default: 50)"),
+  includePath: flexBool(import_zod11.z.boolean()).optional().describe("Include ancestor path strings (default: true). Set false to reduce payload."),
+  includeGeometry: flexBool(import_zod11.z.boolean()).optional().describe("Include absoluteX/absoluteY/width/height (default: true). Set false to reduce payload.")
 });
-function registerMcpTools15(server2, sendCommand) {
-  server2.tool(
-    "create_variable_collection",
-    "Create variable collections. Batch: pass multiple items.",
-    { items: flexJson(import_zod17.z.array(collectionItem)).describe("Array of {name}") },
-    async ({ items }) => {
-      try {
-        return mcpJson(await sendCommand("create_variable_collection", { items }));
-      } catch (e) {
-        return mcpError("Error creating variable collection", e);
-      }
-    }
-  );
-  server2.tool(
-    "create_variable",
-    "Create variables in a collection. Batch: pass multiple items.",
-    { items: flexJson(import_zod17.z.array(variableItem)).describe("Array of {collectionId, name, resolvedType}") },
-    async ({ items }) => {
-      try {
-        return mcpJson(await sendCommand("create_variable", { items }));
-      } catch (e) {
-        return mcpError("Error creating variable", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_variable_value",
-    "Set variable values for modes. Batch: pass multiple items.",
-    { items: flexJson(import_zod17.z.array(setValueItem)).describe("Array of {variableId, modeId, value}") },
-    async ({ items }) => {
-      try {
-        return mcpJson(await sendCommand("set_variable_value", { items }));
-      } catch (e) {
-        return mcpError("Error setting variable value", e);
-      }
-    }
-  );
-  server2.tool(
-    "get_local_variables",
-    "List local variables. Pass includeValues:true to get all mode values in bulk (avoids N separate get_variable_by_id calls).",
-    {
-      type: import_zod17.z.enum(["COLOR", "FLOAT", "STRING", "BOOLEAN"]).optional().describe("Filter by type"),
-      collectionId: import_zod17.z.string().optional().describe("Filter by collection. Omit for all collections."),
-      includeValues: flexBool(import_zod17.z.boolean()).optional().describe("Include valuesByMode for each variable (default: false)")
-    },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("get_local_variables", params));
-      } catch (e) {
-        return mcpError("Error getting variables", e);
-      }
-    }
-  );
-  server2.tool(
-    "get_local_variable_collections",
-    "List all local variable collections.",
-    {},
-    async () => {
-      try {
-        return mcpJson(await sendCommand("get_local_variable_collections"));
-      } catch (e) {
-        return mcpError("Error getting variable collections", e);
-      }
-    }
-  );
-  server2.tool(
-    "get_variable_by_id",
-    "Get detailed variable info including all mode values.",
-    { variableId: import_zod17.z.string().describe("Variable ID") },
-    async ({ variableId }) => {
-      try {
-        return mcpJson(await sendCommand("get_variable_by_id", { variableId }));
-      } catch (e) {
-        return mcpError("Error getting variable", e);
-      }
-    }
-  );
-  server2.tool(
-    "get_variable_collection_by_id",
-    "Get detailed variable collection info including modes and variable IDs.",
-    { collectionId: import_zod17.z.string().describe("Collection ID") },
-    async ({ collectionId }) => {
-      try {
-        return mcpJson(await sendCommand("get_variable_collection_by_id", { collectionId }));
-      } catch (e) {
-        return mcpError("Error getting variable collection", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_variable_binding",
-    "Bind variables to node properties. Common fields: 'fills/0/color', 'strokes/0/color', 'opacity', 'topLeftRadius', 'itemSpacing'. Batch: pass multiple items.",
-    { items: flexJson(import_zod17.z.array(bindingItem)).describe("Array of {nodeId, field, variableId}") },
-    async ({ items }) => {
-      try {
-        return mcpJson(await sendCommand("set_variable_binding", { items }));
-      } catch (e) {
-        return mcpError("Error binding variable", e);
-      }
-    }
-  );
-  server2.tool(
-    "add_mode",
-    "Add modes to variable collections. Batch: pass multiple items.",
-    { items: flexJson(import_zod17.z.array(addModeItem)).describe("Array of {collectionId, name}") },
-    async ({ items }) => {
-      try {
-        return mcpJson(await sendCommand("add_mode", { items }));
-      } catch (e) {
-        return mcpError("Error adding mode", e);
-      }
-    }
-  );
-  server2.tool(
-    "rename_mode",
-    "Rename modes in variable collections. Batch: pass multiple items.",
-    { items: flexJson(import_zod17.z.array(renameModeItem)).describe("Array of {collectionId, modeId, name}") },
-    async ({ items }) => {
-      try {
-        return mcpJson(await sendCommand("rename_mode", { items }));
-      } catch (e) {
-        return mcpError("Error renaming mode", e);
-      }
-    }
-  );
-  server2.tool(
-    "remove_mode",
-    "Remove modes from variable collections. Batch: pass multiple items.",
-    { items: flexJson(import_zod17.z.array(removeModeItem)).describe("Array of {collectionId, modeId}") },
-    async ({ items }) => {
-      try {
-        return mcpJson(await sendCommand("remove_mode", { items }));
-      } catch (e) {
-        return mcpError("Error removing mode", e);
-      }
-    }
-  );
-  server2.tool(
-    "set_explicit_variable_mode",
-    "Pin a variable collection mode on a frame (e.g. show Dark mode). Batch: pass multiple items.",
-    { items: flexJson(import_zod17.z.array(setExplicitModeItem)).describe("Array of {nodeId, collectionId, modeId}") },
-    async ({ items }) => {
-      try {
-        return mcpJson(await sendCommand("set_explicit_variable_mode", { items }));
-      } catch (e) {
-        return mcpError("Error setting variable mode", e);
-      }
-    }
-  );
-  server2.tool(
-    "get_node_variables",
-    "Get variable bindings on a node. Returns which variables are bound to fills, strokes, opacity, corner radius, etc.",
-    { nodeId },
-    async ({ nodeId: nodeId2 }) => {
-      try {
-        return mcpJson(await sendCommand("get_node_variables", { nodeId: nodeId2 }));
-      } catch (e) {
-        return mcpError("Error getting node variables", e);
-      }
-    }
-  );
-  server2.tool(
-    "delete_variable_collection",
-    "Delete a variable collection and all its variables. This is destructive and cannot be undone.",
-    { collectionId: import_zod17.z.string().describe("Collection ID to delete") },
-    async ({ collectionId }) => {
-      try {
-        return mcpJson(await sendCommand("delete_variable_collection", { collectionId }));
-      } catch (e) {
-        return mcpError("Error deleting variable collection", e);
-      }
-    }
-  );
-}
+var tools10 = [
+  {
+    name: "set_text_content",
+    description: "Set text content on text nodes. Batch: pass multiple items to replace text in multiple nodes at once.",
+    schema: { items: flexJson(import_zod11.z.array(textContentItem)).describe("Array of {nodeId, text}"), depth },
+    tier: "edit"
+  },
+  {
+    name: "scan_text_nodes",
+    description: "Scan all text nodes within a node tree. Batch: pass multiple items.",
+    schema: { items: flexJson(import_zod11.z.array(scanTextItem)).describe("Array of {nodeId}") },
+    tier: "read"
+  }
+];
 
-// src/tools/lint.ts
-var import_zod18 = require("zod");
-init_color();
-var lintRules = import_zod18.z.enum([
+// src/tools/defs/fonts.ts
+var import_zod12 = require("zod");
+var tools11 = [
+  {
+    name: "get_available_fonts",
+    description: "Get available fonts in Figma. Optionally filter by query string.",
+    schema: { query: import_zod12.z.string().optional().describe("Filter fonts by name (case-insensitive). Omit to list all fonts.") },
+    tier: "read"
+  }
+];
+
+// src/tools/defs/lint.ts
+var import_zod13 = require("zod");
+var lintRules = import_zod13.z.enum([
   "no-autolayout",
-  // Frames with >1 child and no auto-layout
   "shape-instead-of-frame",
-  // Shapes used where FRAME should be
   "hardcoded-color",
-  // Fills/strokes not using styles
   "no-text-style",
-  // Text nodes without text style
   "fixed-in-autolayout",
-  // Fixed-size children in auto-layout parents
   "default-name",
-  // Nodes with default/unnamed names
   "empty-container",
-  // Frames/components with layout but no children
   "stale-text-name",
-  // Text nodes where layer name diverges from content
   "no-text-property",
-  // Text in components not bound to a component property
-  // ── WCAG 2.2 rules ──
   "wcag-contrast",
-  // 1.4.3 AA text contrast (4.5:1 / 3:1 large)
   "wcag-contrast-enhanced",
-  // 1.4.6 AAA text contrast (7:1 / 4.5:1 large)
   "wcag-non-text-contrast",
-  // 1.4.11 AA non-text contrast (3:1)
   "wcag-target-size",
-  // 2.5.8 AA target size minimum (24x24px)
   "wcag-text-size",
-  // Best practice: minimum readable text (12px)
   "wcag-line-height",
-  // 1.4.12 AA text spacing (line height 1.5x)
   "wcag",
-  // Meta: run all wcag-* rules
   "all"
-  // Run all rules (including WCAG)
 ]);
-function registerMcpTools16(server2, sendCommand) {
-  server2.tool(
-    "lint_node",
-    "Run design linter on a node tree. Returns issues grouped by category with affected node IDs and fix instructions. Lint child nodes individually for large trees.",
-    {
-      nodeId: import_zod18.z.string().optional().describe("Node ID to lint. Omit to lint current selection."),
-      rules: flexJson(import_zod18.z.array(lintRules)).optional().describe('Rules to run. Default: ["all"]. Options: no-autolayout, shape-instead-of-frame, hardcoded-color, no-text-style, fixed-in-autolayout, default-name, empty-container, stale-text-name, no-text-property, all, wcag-contrast, wcag-contrast-enhanced, wcag-non-text-contrast, wcag-target-size, wcag-text-size, wcag-line-height, wcag'),
-      maxDepth: import_zod18.z.coerce.number().optional().describe("Max depth to recurse (default: 10)"),
-      maxFindings: import_zod18.z.coerce.number().optional().describe("Stop after N findings (default: 50)")
+var tools12 = [
+  {
+    name: "lint_node",
+    description: "Run design linter on a node tree. Returns issues grouped by category with affected node IDs and fix instructions. Lint child nodes individually for large trees.",
+    schema: {
+      nodeId: import_zod13.z.string().optional().describe("Node ID to lint. Omit to lint current selection."),
+      rules: flexJson(import_zod13.z.array(lintRules)).optional().describe('Rules to run. Default: ["all"]. Options: no-autolayout, shape-instead-of-frame, hardcoded-color, no-text-style, fixed-in-autolayout, default-name, empty-container, stale-text-name, no-text-property, all, wcag-contrast, wcag-contrast-enhanced, wcag-non-text-contrast, wcag-target-size, wcag-text-size, wcag-line-height, wcag'),
+      maxDepth: import_zod13.z.coerce.number().optional().describe("Max depth to recurse (default: 10)"),
+      maxFindings: import_zod13.z.coerce.number().optional().describe("Stop after N findings (default: 50)")
     },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("lint_node", params));
-      } catch (e) {
-        return mcpError("Error running lint", e);
-      }
-    }
-  );
-  server2.tool(
-    "lint_fix_autolayout",
-    "Auto-fix: convert frames with multiple children to auto-layout. Takes node IDs from lint_node 'no-autolayout' results.",
-    {
-      items: flexJson(import_zod18.z.array(import_zod18.z.object({
+    tier: "read"
+  },
+  {
+    name: "lint_fix_autolayout",
+    description: "Auto-fix: convert frames with multiple children to auto-layout. Takes node IDs from lint_node 'no-autolayout' results.",
+    schema: {
+      items: flexJson(import_zod13.z.array(import_zod13.z.object({
         nodeId,
-        layoutMode: import_zod18.z.enum(["HORIZONTAL", "VERTICAL"]).optional().describe("Layout direction (default: auto-detect based on child positions)"),
-        itemSpacing: import_zod18.z.coerce.number().optional().describe("Spacing between children (default: 0)")
+        layoutMode: import_zod13.z.enum(["HORIZONTAL", "VERTICAL"]).optional().describe("Layout direction (default: auto-detect based on child positions)"),
+        itemSpacing: import_zod13.z.coerce.number().optional().describe("Spacing between children (default: 0)")
       }))).describe("Array of frames to convert to auto-layout"),
       depth
     },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("lint_fix_autolayout", params));
-      } catch (e) {
-        return mcpError("Error fixing auto-layout", e);
+    tier: "edit"
+  }
+];
+
+// src/tools/defs/styles.ts
+var import_zod15 = require("zod");
+
+// src/tools/endpoint.ts
+var import_zod14 = require("zod");
+var DEFAULT_TIERS = {
+  get: "read",
+  list: "read",
+  create: "create",
+  update: "edit",
+  delete: "edit"
+};
+function endpointSchema(methods, capsOrExtra, extraOrTiers, methodTiers) {
+  let caps2;
+  let extra;
+  if (capsOrExtra && "create" in capsOrExtra && "edit" in capsOrExtra && typeof capsOrExtra.create === "boolean") {
+    caps2 = capsOrExtra;
+    extra = extraOrTiers;
+  } else {
+    extra = capsOrExtra;
+  }
+  let filtered = methods;
+  if (caps2) {
+    const tiers = { ...DEFAULT_TIERS, ...methodTiers };
+    filtered = methods.filter((m) => {
+      const tier = tiers[m] ?? "edit";
+      if (tier === "read") return true;
+      if (tier === "create") return caps2.create;
+      if (tier === "edit") return caps2.edit;
+      return false;
+    });
+  }
+  const schema = {
+    method: import_zod14.z.enum(filtered)
+  };
+  if (filtered.includes("get") || filtered.includes("delete")) {
+    schema.id = import_zod14.z.string().optional().describe("Resource ID (get, delete)");
+  }
+  if (filtered.includes("get") || filtered.includes("list")) {
+    schema.fields = flexJson(import_zod14.z.array(import_zod14.z.string())).optional().describe('Property whitelist (get/list). Identity fields (id, name, type) always included. Omit for stubs on list, full detail on get. Pass ["*"] for all fields.');
+  }
+  if (filtered.includes("list")) {
+    schema.offset = import_zod14.z.coerce.number().optional().describe("Skip N items for pagination (default 0)");
+    schema.limit = import_zod14.z.coerce.number().optional().describe("Max items per page (default 100)");
+  }
+  return { ...schema, ...extra };
+}
+
+// src/tools/defs/styles.ts
+var paintStyleItem = import_zod15.z.object({
+  name: import_zod15.z.string().describe("Style name"),
+  color: flexJson(colorRgba).describe("Color.")
+});
+var textStyleItem = import_zod15.z.object({
+  name: import_zod15.z.string().describe("Style name"),
+  fontFamily: import_zod15.z.string().describe("Font family"),
+  fontStyle: import_zod15.z.string().optional().describe("Font style (default: Regular)"),
+  fontSize: import_zod15.z.coerce.number().describe("Font size"),
+  lineHeight: flexNum(import_zod15.z.union([
+    import_zod15.z.number(),
+    import_zod15.z.object({ value: import_zod15.z.coerce.number(), unit: import_zod15.z.enum(["PIXELS", "PERCENT", "AUTO"]) })
+  ])).optional().describe("Line height \u2014 number (px) or {value, unit}. Default: auto."),
+  letterSpacing: flexNum(import_zod15.z.union([
+    import_zod15.z.number(),
+    import_zod15.z.object({ value: import_zod15.z.coerce.number(), unit: import_zod15.z.enum(["PIXELS", "PERCENT"]) })
+  ])).optional().describe("Letter spacing \u2014 number (px) or {value, unit}. Default: 0."),
+  textCase: import_zod15.z.enum(["ORIGINAL", "UPPER", "LOWER", "TITLE"]).optional(),
+  textDecoration: import_zod15.z.enum(["NONE", "UNDERLINE", "STRIKETHROUGH"]).optional()
+});
+var effectStyleItem = import_zod15.z.object({
+  name: import_zod15.z.string().describe("Style name"),
+  effects: flexJson(import_zod15.z.array(effectEntry)).describe("Array of effects")
+});
+var patchBase = {
+  id: import_zod15.z.string().describe("Style ID or name (case-insensitive match)"),
+  name: import_zod15.z.string().optional().describe("Rename the style")
+};
+var patchPaintItem = import_zod15.z.object({
+  ...patchBase,
+  color: flexJson(colorRgba).optional().describe("New color.")
+});
+var patchTextItem = import_zod15.z.object({
+  ...patchBase,
+  fontFamily: import_zod15.z.string().optional().describe("Font family"),
+  fontStyle: import_zod15.z.string().optional().describe("Font style, e.g. Regular, Bold"),
+  fontSize: import_zod15.z.coerce.number().optional().describe("Font size"),
+  lineHeight: flexNum(import_zod15.z.union([
+    import_zod15.z.number(),
+    import_zod15.z.object({ value: import_zod15.z.coerce.number(), unit: import_zod15.z.enum(["PIXELS", "PERCENT", "AUTO"]) })
+  ])).optional().describe("Line height \u2014 number (px) or {value, unit}"),
+  letterSpacing: flexNum(import_zod15.z.union([
+    import_zod15.z.number(),
+    import_zod15.z.object({ value: import_zod15.z.coerce.number(), unit: import_zod15.z.enum(["PIXELS", "PERCENT"]) })
+  ])).optional().describe("Letter spacing \u2014 number (px) or {value, unit}"),
+  textCase: import_zod15.z.enum(["ORIGINAL", "UPPER", "LOWER", "TITLE"]).optional(),
+  textDecoration: import_zod15.z.enum(["NONE", "UNDERLINE", "STRIKETHROUGH"]).optional()
+});
+var patchEffectItem = import_zod15.z.object({
+  ...patchBase,
+  effects: flexJson(import_zod15.z.array(effectEntry)).optional().describe("Array of effects")
+});
+var patchAnyItem = import_zod15.z.object({
+  ...patchBase,
+  color: flexJson(colorRgba).optional(),
+  fontFamily: import_zod15.z.string().optional(),
+  fontStyle: import_zod15.z.string().optional(),
+  fontSize: import_zod15.z.coerce.number().optional(),
+  lineHeight: flexNum(import_zod15.z.union([
+    import_zod15.z.number(),
+    import_zod15.z.object({ value: import_zod15.z.coerce.number(), unit: import_zod15.z.enum(["PIXELS", "PERCENT", "AUTO"]) })
+  ])).optional(),
+  letterSpacing: flexNum(import_zod15.z.union([
+    import_zod15.z.number(),
+    import_zod15.z.object({ value: import_zod15.z.coerce.number(), unit: import_zod15.z.enum(["PIXELS", "PERCENT"]) })
+  ])).optional(),
+  textCase: import_zod15.z.enum(["ORIGINAL", "UPPER", "LOWER", "TITLE"]).optional(),
+  textDecoration: import_zod15.z.enum(["NONE", "UNDERLINE", "STRIKETHROUGH"]).optional(),
+  effects: flexJson(import_zod15.z.array(effectEntry)).optional()
+});
+var createSchemas = {
+  paint: paintStyleItem,
+  text: textStyleItem,
+  effect: effectStyleItem
+};
+var updateSchemas = {
+  paint: patchPaintItem,
+  text: patchTextItem,
+  effect: patchEffectItem
+};
+var tools13 = [
+  {
+    name: "styles",
+    description: "CRUD endpoint for local styles (paint, text, effect).\n  list   \u2192 {type?, fields?, offset?, limit?} \u2192 {totalCount, items: [{id, name, type, ...}]}\n  get    \u2192 {id, fields?} \u2192 style object (full detail; fields to filter)\n  create \u2192 {type, items: [...]} \u2192 {results: [{id}, ...]}\n  update \u2192 {type?, items: [{id, ...}]} \u2192 {results: ['ok'|{warning}, ...]}\n  delete \u2192 {id} or {items: [{id}, ...]} \u2192 'ok' or {results: ['ok', ...]}",
+    schema: (caps2) => endpointSchema(
+      ["create", "get", "list", "update", "delete"],
+      caps2,
+      {
+        type: import_zod15.z.enum(["paint", "text", "effect"]).optional().describe("Style type. Required for create. Filters list by type. Optional for update (strict per-type validation; omit to auto-detect)."),
+        items: flexJson(import_zod15.z.array(import_zod15.z.any())).optional().describe("Create: [{name, color}] (paint), [{name, fontFamily, fontSize, ...}] (text), [{name, effects}] (effect). Update: [{id, ...fields}]. Delete (batch): [{id}, ...]."),
+        depth
+      }
+    ),
+    tier: "read",
+    validate: (params) => {
+      if (params.items) {
+        const map = params.method === "update" ? updateSchemas : createSchemas;
+        const itemSchema = params.type && map[params.type] || patchAnyItem;
+        params.items = import_zod15.z.array(itemSchema).parse(params.items);
       }
     }
-  );
-  server2.tool(
-    "lint_fix_replace_shape_with_frame",
-    "Auto-fix: replace shapes with frames preserving visual properties. Overlapping siblings are re-parented into the new frame. Use after lint_node 'shape-instead-of-frame' results.",
-    {
-      items: flexJson(import_zod18.z.array(import_zod18.z.object({
-        nodeId,
-        adoptChildren: flexBool(import_zod18.z.boolean()).optional().describe("Re-parent overlapping siblings into the new frame (default: true)")
-      }))).describe("Array of shapes to convert to frames"),
-      depth
-    },
-    async (params) => {
-      try {
-        return mcpJson(await sendCommand("lint_fix_replace_shape_with_frame", params));
-      } catch (e) {
-        return mcpError("Error converting shapes to frames", e);
+  }
+];
+
+// src/tools/defs/variables.ts
+var import_zod16 = require("zod");
+var collectionCreateItem = import_zod16.z.object({
+  name: import_zod16.z.string().describe("Collection name")
+});
+var addModeItem = import_zod16.z.object({
+  collectionId: import_zod16.z.string().describe("Collection ID"),
+  name: import_zod16.z.string().describe("Mode name")
+});
+var renameModeItem = import_zod16.z.object({
+  collectionId: import_zod16.z.string().describe("Collection ID"),
+  modeId: import_zod16.z.string().describe("Mode ID"),
+  name: import_zod16.z.string().describe("New name")
+});
+var removeModeItem = import_zod16.z.object({
+  collectionId: import_zod16.z.string().describe("Collection ID"),
+  modeId: import_zod16.z.string().describe("Mode ID")
+});
+var deleteCollectionItem = import_zod16.z.object({
+  id: import_zod16.z.string().describe("Collection ID")
+});
+var collectionMethodSchemas = {
+  create: collectionCreateItem,
+  delete: deleteCollectionItem,
+  add_mode: addModeItem,
+  rename_mode: renameModeItem,
+  remove_mode: removeModeItem
+};
+var variableCreateItem = import_zod16.z.object({
+  collectionId: import_zod16.z.string().describe("Variable collection ID"),
+  name: import_zod16.z.string().describe("Variable name"),
+  resolvedType: import_zod16.z.enum(["COLOR", "FLOAT", "STRING", "BOOLEAN"]).describe("Variable type")
+});
+var variableUpdateItem = import_zod16.z.object({
+  id: import_zod16.z.string().describe("Variable ID (full ID, e.g. VariableID:1:6)"),
+  modeId: import_zod16.z.string().describe("Mode ID"),
+  value: flexJson(import_zod16.z.union([
+    import_zod16.z.number(),
+    import_zod16.z.boolean(),
+    colorRgba
+  ])).describe('Value: number, boolean, or color (hex "#RRGGBB" or {r,g,b,a?} 0-1)')
+});
+var variableMethodSchemas = {
+  create: variableCreateItem,
+  update: variableUpdateItem
+};
+var bindingItem = import_zod16.z.object({
+  nodeId: import_zod16.z.string().describe("Node ID"),
+  field: import_zod16.z.string().describe("Property field (e.g., 'opacity', 'fills/0/color')"),
+  variableId: import_zod16.z.string().describe("Variable ID (use full ID from create_variable response, e.g. VariableID:1:6)")
+});
+var setExplicitModeItem = import_zod16.z.object({
+  nodeId,
+  collectionId: import_zod16.z.string().describe("Variable collection ID"),
+  modeId: import_zod16.z.string().describe("Mode ID to pin (e.g. Dark mode)")
+});
+var vcMethodTiers = {
+  add_mode: "create",
+  rename_mode: "edit",
+  remove_mode: "edit"
+};
+var tools14 = [
+  {
+    name: "variable_collections",
+    description: `CRUD endpoint for variable collections + mode management.
+  create       \u2192 {items: [{name}]}                          \u2192 {results: [{id, modes, defaultModeId}]}
+  get          \u2192 {id, fields?}                              \u2192 collection object
+  list         \u2192 {fields?, offset?, limit?}                 \u2192 paginated stubs
+  delete       \u2192 {id} or {items: [{id}]}                    \u2192 'ok' or {results: ['ok', ...]}
+  add_mode     \u2192 {items: [{collectionId, name}]}            \u2192 {results: [{modeId, modes}]}
+  rename_mode  \u2192 {items: [{collectionId, modeId, name}]}    \u2192 {results: [{modes}]}
+  remove_mode  \u2192 {items: [{collectionId, modeId}]}          \u2192 {results: [{modes}]}`,
+    schema: (caps2) => endpointSchema(
+      ["create", "get", "list", "delete", "add_mode", "rename_mode", "remove_mode"],
+      caps2,
+      {
+        items: flexJson(import_zod16.z.array(import_zod16.z.any())).optional().describe("create: [{name}]. delete (batch): [{id}]. add_mode: [{collectionId, name}]. rename_mode: [{collectionId, modeId, name}]. remove_mode: [{collectionId, modeId}].")
+      },
+      vcMethodTiers
+    ),
+    tier: "read",
+    validate: (params) => {
+      if (params.items) {
+        const schema = collectionMethodSchemas[params.method];
+        if (schema) params.items = import_zod16.z.array(schema).parse(params.items);
       }
     }
-  );
-}
+  },
+  {
+    name: "variables",
+    description: `CRUD endpoint for design variables.
+  create  \u2192 {items: [{collectionId, name, resolvedType}]}   \u2192 {results: [{id}]}
+  get     \u2192 {id, fields?}                                   \u2192 variable object (full detail)
+  list    \u2192 {type?, collectionId?, fields?, offset?, limit?} \u2192 paginated stubs (fields for detail)
+  update  \u2192 {items: [{id, modeId, value}]}                  \u2192 {results: ['ok', ...]}`,
+    schema: (caps2) => endpointSchema(
+      ["create", "get", "list", "update"],
+      caps2,
+      {
+        items: flexJson(import_zod16.z.array(import_zod16.z.any())).optional().describe("create: [{collectionId, name, resolvedType}]. update: [{id, modeId, value}]."),
+        type: import_zod16.z.enum(["COLOR", "FLOAT", "STRING", "BOOLEAN"]).optional().describe("Filter list by variable type."),
+        collectionId: import_zod16.z.string().optional().describe("Filter list by collection ID.")
+      }
+    ),
+    tier: "read",
+    validate: (params) => {
+      if (params.items) {
+        const schema = variableMethodSchemas[params.method];
+        if (schema) params.items = import_zod16.z.array(schema).parse(params.items);
+      }
+    }
+  },
+  {
+    name: "set_variable_binding",
+    description: "Bind variables to node properties. Common fields: 'fills/0/color', 'strokes/0/color', 'opacity', 'topLeftRadius', 'itemSpacing'. Batch: pass multiple items.",
+    schema: { items: flexJson(import_zod16.z.array(bindingItem)).describe("Array of {nodeId, field, variableId}") },
+    tier: "edit"
+  },
+  {
+    name: "set_explicit_variable_mode",
+    description: "Pin a variable collection mode on a frame (e.g. show Dark mode). Batch: pass multiple items.",
+    schema: { items: flexJson(import_zod16.z.array(setExplicitModeItem)).describe("Array of {nodeId, collectionId, modeId}") },
+    tier: "edit"
+  },
+  {
+    name: "get_node_variables",
+    description: "Get variable bindings on a node. Returns which variables are bound to fills, strokes, opacity, corner radius, etc.",
+    schema: { nodeId },
+    tier: "read"
+  }
+];
 
-// src/tools/connection.ts
-function registerMcpTools17(server2, sendCommand) {
-  server2.tool(
-    "ping",
-    "Verify end-to-end connection to Figma. Call this right after join_channel. Returns { status: 'pong', documentName, currentPage } if the full chain (MCP \u2192 relay \u2192 plugin \u2192 Figma) is working. If this times out, the Figma plugin is not connected \u2014 ask the user to check the plugin window for the correct port and channel name.",
-    {},
-    async () => {
-      try {
-        return mcpJson(await sendCommand("ping", {}, 5e3));
-      } catch (e) {
-        return mcpError("Connection verification failed", e);
+// src/tools/defs/components.ts
+var import_zod17 = require("zod");
+var componentItem = import_zod17.z.object({
+  name: import_zod17.z.string().describe("Component name"),
+  x: xPos,
+  y: yPos,
+  width: import_zod17.z.coerce.number().optional().describe("Width (default: 100)"),
+  height: import_zod17.z.coerce.number().optional().describe("Height (default: 100)"),
+  parentId,
+  fillColor: flexJson(colorRgba).optional().describe("Fill color. Omit for no fill."),
+  fillStyleName: import_zod17.z.string().optional().describe("Apply a fill paint style by name (case-insensitive)."),
+  fillVariableId: import_zod17.z.string().optional().describe("Bind a color variable to the fill."),
+  strokeColor: flexJson(colorRgba).optional().describe("Stroke color. Omit for no stroke."),
+  strokeStyleName: import_zod17.z.string().optional().describe("Apply a stroke paint style by name."),
+  strokeVariableId: import_zod17.z.string().optional().describe("Bind a color variable to the stroke."),
+  strokeWeight: import_zod17.z.coerce.number().positive().optional().describe("Stroke weight (default: 1)"),
+  cornerRadius: import_zod17.z.coerce.number().optional().describe("Corner radius (default: 0)"),
+  layoutMode: import_zod17.z.enum(["NONE", "HORIZONTAL", "VERTICAL"]).optional().describe("Layout direction (default: NONE)"),
+  layoutWrap: import_zod17.z.enum(["NO_WRAP", "WRAP"]).optional().describe("Wrap behavior (default: NO_WRAP)"),
+  paddingTop: import_zod17.z.coerce.number().optional().describe("Top padding (default: 0)"),
+  paddingRight: import_zod17.z.coerce.number().optional().describe("Right padding (default: 0)"),
+  paddingBottom: import_zod17.z.coerce.number().optional().describe("Bottom padding (default: 0)"),
+  paddingLeft: import_zod17.z.coerce.number().optional().describe("Left padding (default: 0)"),
+  primaryAxisAlignItems: import_zod17.z.enum(["MIN", "MAX", "CENTER", "SPACE_BETWEEN"]).optional().describe("Primary axis alignment (default: MIN)"),
+  counterAxisAlignItems: import_zod17.z.enum(["MIN", "MAX", "CENTER", "BASELINE"]).optional().describe("Counter axis alignment (default: MIN)"),
+  layoutSizingHorizontal: import_zod17.z.enum(["FIXED", "HUG", "FILL"]).optional().describe("Horizontal sizing (default: FIXED)"),
+  layoutSizingVertical: import_zod17.z.enum(["FIXED", "HUG", "FILL"]).optional().describe("Vertical sizing (default: FIXED)"),
+  itemSpacing: import_zod17.z.coerce.number().optional().describe("Spacing between children (default: 0)")
+});
+var fromNodeItem = import_zod17.z.object({
+  nodeId
+});
+var combineItem = import_zod17.z.object({
+  componentIds: flexJson(import_zod17.z.array(import_zod17.z.string())).describe("Component IDs to combine (min 2)"),
+  name: import_zod17.z.string().optional().describe("Name for the component set. Omit to auto-generate.")
+});
+var updateComponentItem = import_zod17.z.object({
+  id: import_zod17.z.string().describe("Component node ID"),
+  propertyName: import_zod17.z.string().describe("Property name"),
+  type: import_zod17.z.enum(["BOOLEAN", "TEXT", "INSTANCE_SWAP", "VARIANT"]).describe("Property type"),
+  defaultValue: flexBool(import_zod17.z.union([import_zod17.z.string(), import_zod17.z.boolean()])).describe("Default value (string for TEXT/VARIANT, boolean for BOOLEAN)"),
+  preferredValues: flexJson(import_zod17.z.array(import_zod17.z.object({
+    type: import_zod17.z.enum(["COMPONENT", "COMPONENT_SET"]),
+    key: import_zod17.z.string()
+  })).optional()).describe("Preferred values for INSTANCE_SWAP type. Omit for none.")
+});
+var componentCreateSchemas = {
+  component: componentItem,
+  from_node: fromNodeItem,
+  variant_set: combineItem
+};
+var instanceCreateItem = import_zod17.z.object({
+  componentId: import_zod17.z.string().describe("Component or component set ID"),
+  variantProperties: flexJson(import_zod17.z.record(import_zod17.z.string(), import_zod17.z.string())).optional().describe('Pick variant by properties, e.g. {"Style":"Secondary","Size":"Large"}. Ignored for plain COMPONENT IDs.'),
+  x: import_zod17.z.coerce.number().optional().describe("X position. Omit to keep default."),
+  y: import_zod17.z.coerce.number().optional().describe("Y position. Omit to keep default."),
+  parentId
+});
+var instanceUpdateItem = import_zod17.z.object({
+  id: nodeId,
+  properties: flexJson(import_zod17.z.record(import_zod17.z.string(), import_zod17.z.union([import_zod17.z.string(), import_zod17.z.boolean()]))).describe('Property key\u2192value map, e.g. {"Label#1:0":"Click Me"}')
+});
+var tools15 = [
+  {
+    name: "components",
+    description: `CRUD endpoint for components.
+  create  \u2192 {type, items, depth?} \u2192 {results: [{id}, ...]}
+    type 'component': create from scratch with layout/style params
+    type 'from_node': convert existing nodes to components
+    type 'variant_set': combine components into variant sets
+  get     \u2192 {id, fields?} \u2192 component object (full detail, field-filterable)
+  list    \u2192 {name?, setsOnly?, fields?, offset?, limit?} \u2192 paginated stubs
+  update  \u2192 {items: [{id, propertyName, type, defaultValue}]} \u2192 {results: ['ok', ...]}`,
+    schema: (caps2) => endpointSchema(
+      ["create", "get", "list", "update"],
+      caps2,
+      {
+        items: flexJson(import_zod17.z.array(import_zod17.z.any())).optional().describe("create (component): [{name, parentId?, ...layout}]. create (from_node): [{nodeId}]. create (variant_set): [{componentIds, name?}]. update: [{id, propertyName, type, defaultValue}]."),
+        type: import_zod17.z.enum(["component", "from_node", "variant_set"]).optional().describe("Create type. Required for create: 'component' (from scratch), 'from_node' (convert existing), 'variant_set' (combine as variants)."),
+        depth,
+        name: import_zod17.z.string().optional().describe("Filter list by name (case-insensitive substring)."),
+        setsOnly: flexBool(import_zod17.z.boolean()).optional().describe("If true, list returns only COMPONENT_SET nodes.")
+      }
+    ),
+    tier: "read",
+    validate: (params) => {
+      if (params.items) {
+        if (params.method === "create") {
+          const schema = params.type && componentCreateSchemas[params.type];
+          if (!schema) throw new Error(`create requires type: component, from_node, or variant_set`);
+          params.items = import_zod17.z.array(schema).parse(params.items);
+        } else if (params.method === "update") {
+          params.items = import_zod17.z.array(updateComponentItem).parse(params.items);
+        }
       }
     }
-  );
-}
+  },
+  {
+    name: "instances",
+    description: `CRUD endpoint for component instances.
+  create  \u2192 {items: [{componentId, variantProperties?, x?, y?, parentId?}], depth?} \u2192 {results: [{id}]}
+  get     \u2192 {id} \u2192 {mainComponentId, overrides: [{id, fields}]}
+  update  \u2192 {items: [{id, properties}]} \u2192 {results: ['ok', ...]}`,
+    schema: (caps2) => endpointSchema(
+      ["create", "get", "update"],
+      caps2,
+      {
+        items: flexJson(import_zod17.z.array(import_zod17.z.any())).optional().describe("create: [{componentId, variantProperties?, x?, y?, parentId?}]. update: [{id, properties}]."),
+        depth
+      }
+    ),
+    tier: "read",
+    validate: (params) => {
+      if (params.items) {
+        if (params.method === "create") {
+          params.items = import_zod17.z.array(instanceCreateItem).parse(params.items);
+        } else if (params.method === "update") {
+          params.items = import_zod17.z.array(instanceUpdateItem).parse(params.items);
+        }
+      }
+    }
+  }
+];
 
 // src/tools/prompts.ts
 function registerPrompts(server2) {
-  server2.prompt(
+  server2.registerPrompt(
     "design_strategy",
-    "Best practices for working with Figma designs",
+    { description: "Best practices for working with Figma designs" },
     () => ({
       messages: [{
         role: "assistant",
@@ -1642,7 +1011,7 @@ function registerPrompts(server2) {
 
 1. Understand Before Creating:
    - Use get_document_info() to see pages and current page
-   - Use get_styles() and get_local_variables() to discover existing design tokens
+   - Use styles(method: "list") and get_local_variables() to discover existing design tokens
    - Plan layout hierarchy before creating elements
 
 2. Use Design Tokens \u2014 Never Hardcode:
@@ -1659,7 +1028,7 @@ function registerPrompts(server2) {
 
 4. Naming Conventions:
    - Use descriptive, semantic names for all elements
-   - Name components with Property=Value pattern (e.g. "Size=Small") before combine_as_variants
+   - Name components with Property=Value pattern (e.g. "Size=Small") before components(method: "create", type: "variant_set")
 
 5. Variable Modes:
    - Use set_explicit_variable_mode() to pin a frame to a specific mode (e.g. Dark)
@@ -1671,16 +1040,16 @@ function registerPrompts(server2) {
      * no-text-style: text without a text style applied
      * no-autolayout: frames with children but no auto-layout
      * default-name: nodes still named "Frame", "Rectangle", etc.
-   - Use lint_fix_autolayout() and lint_fix_replace_shape_with_frame() to auto-fix
+   - Use lint_fix_autolayout() to auto-fix layout issues
    - Lint early and often \u2014 it is cheaper to fix issues during creation than after`
         }
       }],
       description: "Best practices for working with Figma designs"
     })
   );
-  server2.prompt(
+  server2.registerPrompt(
     "read_design_strategy",
-    "Best practices for reading Figma designs",
+    { description: "Best practices for reading Figma designs" },
     () => ({
       messages: [{
         role: "assistant",
@@ -1689,7 +1058,7 @@ function registerPrompts(server2) {
           text: `When reading Figma designs, follow these best practices:
 
 1. Start with selection:
-   - First use read_my_design() to understand the current selection
+   - First use get_selection() to understand the current selection
    - If no selection ask user to select single or multiple nodes
 `
         }
@@ -1697,9 +1066,9 @@ function registerPrompts(server2) {
       description: "Best practices for reading Figma designs"
     })
   );
-  server2.prompt(
+  server2.registerPrompt(
     "text_replacement_strategy",
-    "Systematic approach for replacing text in Figma designs",
+    { description: "Systematic approach for replacing text in Figma designs" },
     () => ({
       messages: [{
         role: "assistant",
@@ -1824,9 +1193,9 @@ Remember that text is never just text\u2014it's a core design element that must
       description: "Systematic approach for replacing text in Figma designs"
     })
   );
-  server2.prompt(
+  server2.registerPrompt(
     "swap_overrides_instances",
-    "Guide to swap instance overrides between instances",
+    { description: "Guide to swap instance overrides between instances" },
     () => ({
       messages: [{
         role: "assistant",
@@ -1844,12 +1213,12 @@ Transfer content overrides from a source instance to target instances.
 - Use \`search_nodes(types: ["INSTANCE"])\` to find instances on the page
 
 ### 2. Extract Source Overrides
-- \`get_instance_overrides(nodeId: "source-instance-id")\`
+- \`instances(method: "get", id: "source-instance-id")\`
 - Returns mainComponentId and per-child override fields (characters, fills, fontSize, etc.)
 
 ### 3. Apply to Targets
 - For text overrides: use \`set_text_content\` on matching child node IDs
-- For style overrides: use \`set_fill_color\`, \`apply_style_to_node\`, etc.
+- For style overrides: use \`patch_nodes\` with fill/stroke/text/effects styleName fields
 - Match children by name path \u2014 source and target instances share the same internal structure
 
 ### 4. Verify
@@ -1863,31 +1232,33 @@ Transfer content overrides from a source instance to target instances.
 }
 
 // src/tools/mcp-registry.ts
-function registerAllTools(server2, sendCommand) {
-  registerMcpTools(server2, sendCommand);
-  registerMcpTools2(server2, sendCommand);
-  registerMcpTools3(server2, sendCommand);
-  registerMcpTools4(server2, sendCommand);
-  registerMcpTools5(server2, sendCommand);
-  registerMcpTools6(server2, sendCommand);
-  registerMcpTools7(server2, sendCommand);
-  registerMcpTools8(server2, sendCommand);
-  registerMcpTools9(server2, sendCommand);
-  registerMcpTools10(server2, sendCommand);
-  registerMcpTools11(server2, sendCommand);
-  registerMcpTools12(server2, sendCommand);
-  registerMcpTools13(server2, sendCommand);
-  registerMcpTools14(server2, sendCommand);
-  registerMcpTools15(server2, sendCommand);
-  registerMcpTools16(server2, sendCommand);
-  registerMcpTools17(server2, sendCommand);
+var allTools = [
+  ...tools,
+  ...tools2,
+  ...tools3,
+  ...tools4,
+  ...tools5,
+  ...tools6,
+  ...tools7,
+  ...tools8,
+  ...tools9,
+  ...tools10,
+  ...tools11,
+  ...tools12,
+  ...tools13,
+  ...tools14,
+  ...tools15
+];
+function registerAllTools(server2, sendCommand, caps2) {
+  registerTools(server2, sendCommand, caps2, allTools);
   registerPrompts(server2);
 }
 
 // src/mcp.ts
+var import_meta = {};
 var VIBMA_VERSION = "0.0.0";
 try {
-  const start = typeof __dirname !== "undefined" ? __dirname : process.cwd();
+  const start = typeof import_meta?.url !== "undefined" ? (0, import_path.join)((0, import_url.fileURLToPath)(import_meta.url), "..") : typeof __dirname !== "undefined" ? __dirname : process.cwd();
   for (let dir = start; dir !== "/"; dir = (0, import_path.join)(dir, "..")) {
     try {
       const pkg = JSON.parse((0, import_fs.readFileSync)((0, import_path.join)(dir, "package.json"), "utf8"));
@@ -1925,6 +1296,10 @@ var portArg = args.find((a) => a.startsWith("--port="));
 var serverUrl = serverArg ? serverArg.split("=")[1] : "localhost";
 if (portArg) activePort = parseInt(portArg.split("=")[1]);
 var WS_URL = serverUrl === "localhost" ? `ws://${serverUrl}` : `wss://${serverUrl}`;
+var caps = {
+  create: args.includes("--create") || args.includes("--edit"),
+  edit: args.includes("--edit")
+};
 function connectToFigma(port = activePort) {
   activePort = port;
   if (ws && ws.readyState === import_ws.default.OPEN) {
@@ -2092,10 +1467,12 @@ var server = new import_mcp.McpServer({
   name: "VibmaMCP",
   version: "1.0.0"
 });
-server.tool(
+server.registerTool(
   "join_channel",
-  "REQUIRED FIRST STEP: Join a channel before using any other tool. The channel name is shown in the Figma plugin UI (defaults to 'vibma' if not customised). After joining, call `ping` to verify the Figma plugin is connected. All subsequent commands are sent through this channel.",
-  { channel: import_zod19.z.string().describe("The channel name displayed in the Figma plugin panel. Defaults to 'vibma' if omitted.").default("vibma") },
+  {
+    description: "REQUIRED FIRST STEP: Join a channel before using any other tool. The channel name is shown in the Figma plugin UI (defaults to 'vibma' if not customised). After joining, call `ping` to verify the Figma plugin is connected. All subsequent commands are sent through this channel.",
+    inputSchema: { channel: import_zod18.z.string().describe("The channel name displayed in the Figma plugin panel. Defaults to 'vibma' if omitted.").default("vibma") }
+  },
   async ({ channel }) => {
     try {
       await joinChannel(channel);
@@ -2118,10 +1495,11 @@ See "Version mismatch" in CARRYME.md or DRAGME.md for update steps.`;
     }
   }
 );
-server.tool(
+server.registerTool(
   "channel_info",
-  "Debug: inspect which clients (MCP, plugin) are connected to each relay channel. Useful for diagnosing connection issues. Does not require an active channel.",
-  {},
+  {
+    description: "Debug: inspect which clients (MCP, plugin) are connected to each relay channel. Useful for diagnosing connection issues. Does not require an active channel."
+  },
   async () => {
     try {
       const url = serverUrl === "localhost" ? `http://localhost:${activePort}/channels` : `https://${serverUrl}/channels`;
@@ -2141,11 +1519,13 @@ server.tool(
     }
   }
 );
-server.tool(
+server.registerTool(
   "reset_tunnel",
-  "DESTRUCTIVE: Factory-reset a channel on the relay via HTTP, disconnecting ALL occupants (MCP + Figma plugin). Only use this when the channel is stuck or occupied by another MCP \u2014 do NOT use it just to reconnect yourself (use `join_channel` instead). After reset, ask the user to reopen the Vibma plugin in Figma, then call `join_channel` and `ping`.",
   {
-    channel: import_zod19.z.string().describe("Channel to reset. Defaults to 'vibma'.").default("vibma")
+    description: "DESTRUCTIVE: Factory-reset a channel on the relay via HTTP, disconnecting ALL occupants (MCP + Figma plugin). Only use this when the channel is stuck or occupied by another MCP \u2014 do NOT use it just to reconnect yourself (use `join_channel` instead). After reset, ask the user to reopen the Vibma plugin in Figma, then call `join_channel` and `ping`.",
+    inputSchema: {
+      channel: import_zod18.z.string().describe("Channel to reset. Defaults to 'vibma'.").default("vibma")
+    }
   },
   async ({ channel }) => {
     const targetChannel = channel || currentChannel || "vibma";
@@ -2189,7 +1569,7 @@ IMPORTANT: The Figma plugin was also disconnected. Ask the user to reopen the Vi
     }
   }
 );
-registerAllTools(server, sendCommandToFigma);
+registerAllTools(server, sendCommandToFigma, caps);
 function cleanup() {
   if (ws && ws.readyState === import_ws.default.OPEN) {
     ws.close(1e3, "MCP server shutting down");