figma-relai 0.1.4 → 0.2.1

package/dist/chunk-EBP7POOP.js

@@ -0,0 +1,3516 @@
+#!/usr/bin/env node
+import {
+  __export
+} from "./chunk-2H7UOFLK.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function createServer() {
+  return new McpServer(
+    {
+      name: "Relai",
+      version: "0.2.1"
+    },
+    {
+      instructions: `
+You control Figma through ~30 consolidated tools. Pairing with the Figma plugin is automatic \u2014 just call any tool; join_room is only needed if an error reports multiple plugins.
+
+\u{1F4D6} UNDERSTAND (start here):
+  get_document_overview \u2014 structure, page/component/style/variable counts
+  get_selection_context \u2014 full context for what the designer selected
+  get_node_details \u2014 deep single-node inspection (CSS, token bindings)
+  search_nodes \u2014 find nodes by name/type \xB7 get_node_data \u2014 raw data/tree/css
+  get_design_tokens \u2014 variable collections, modes, styles
+  screenshot \u2014 see the canvas (use this to verify your work visually)
+
+\u{1F50D} DIAGNOSE:
+  analyze_design \u2014 aspect: color/layout/components/accessibility, or
+    "overall" for a weighted 0-100 health score across all four
+  diff_nodes \u2014 compare two nodes, or checkpoint save/compare to audit
+    what changed on a node over an editing session
+
+\u270F\uFE0F EDIT:
+  create_node \u2014 any node type (rectangle/frame/text/svg/image/\u2026)
+  set_properties \u2014 one call for geometry, fills, strokes, effects, text,
+    auto-layout, constraints, style/variable bindings, on one or many nodes
+  set_text \u2014 single, bulk, or character-range text edits
+  edit_structure \u2014 group/reparent/reorder/clone/flatten/boolean/delete
+  navigate \u2014 focus/select/viewport/switch_page \xB7 manage_pages
+
+\u{1F9F1} DESIGN SYSTEM:
+  manage_components \u2014 create/variants/instantiate/overrides/props/detach
+  manage_variables \u2014 collections, modes, tokens, bind/unbind
+  manage_styles \u2014 paint/text/effect/grid styles
+  import_from_library \u2014 bring in library components/styles/variables
+
+\u{1F4E6} ASSETS: export_asset (PNG/JPG/SVG/PDF) \xB7 add_image (URL or fill)
+\u{1F4DD} ANNOTATIONS: annotate (Dev Mode annotations)
+\u{1F4AC} COMMENTS: manage_comments \u2014 read/apply/reply to file comments
+  (needs FIGMA_TOKEN env; the tool explains setup when missing)
+
+\u2705 VERIFY: verify_changes \xB7 validate_design_rules
+
+\u26A1 ADVANCED:
+  batch_execute \u2014 run many plugin-level commands in one round-trip
+  execute_figma \u2014 run JavaScript against the Figma Plugin API directly
+    (the escape hatch when no tool fits; small incremental scripts,
+     screenshot between steps; the designer can disable it)
+
+OPERATING PRINCIPLES:
+- Inspect context BEFORE changing things; don't assume selection state
+- After visual edits, verify: screenshot or verify_changes
+- Colors are RGBA in 0-1 range (Figma format), not 0-255
+- layoutSizing FILL requires the node's PARENT to have auto-layout;
+  set layoutMode on a frame before padding/alignment/spacing
+- Responses include recommended_next tools \u2014 follow them
+- Errors name the node, its type, and the fix \u2014 read them, don't retry blindly
+`
+    }
+  );
+}
+
+// ../shared/src/types/commands.ts
+var FIGMA_COMMANDS = [
+  // Document & Selection
+  "get_document_info",
+  "get_file_info",
+  "get_selection",
+  "read_my_design",
+  "get_node_info",
+  "get_node_tree",
+  "get_nodes_info",
+  "scan_nodes_by_types",
+  "get_css",
+  "find_nodes",
+  "get_bound_variables",
+  // Creation
+  "create_rectangle",
+  "create_frame",
+  "create_text",
+  "create_ellipse",
+  "create_polygon",
+  "create_star",
+  "create_line",
+  "create_component_instance",
+  "create_section",
+  "create_node_from_svg",
+  "create_connector",
+  "create_table",
+  "create_sticky",
+  "create_code_block",
+  "create_slice",
+  // Modification
+  "move_node",
+  "resize_node",
+  "clone_node",
+  "delete_node",
+  "delete_multiple_nodes",
+  "rename_node",
+  "set_opacity",
+  "reorder_node",
+  "set_visible",
+  "set_locked",
+  "reparent_node",
+  "set_rotation",
+  "set_relaunch_data",
+  "get_relaunch_data",
+  // Styling
+  "set_fill_color",
+  "set_fills",
+  "set_stroke_color",
+  "set_corner_radius",
+  "set_blend_mode",
+  "set_gradient_fill",
+  "set_clips_content",
+  "set_layout_grids",
+  "set_aspect_ratio",
+  // Effects
+  "add_drop_shadow",
+  "add_inner_shadow",
+  "add_blur",
+  "add_background_blur",
+  "remove_effects",
+  // Text
+  "scan_text_nodes",
+  "set_text_content",
+  "set_multiple_text_contents",
+  "set_text_style_range",
+  // Layout
+  "set_layout_mode",
+  "set_padding",
+  "set_axis_align",
+  "set_layout_sizing",
+  "set_item_spacing",
+  // Design system
+  "get_design_system",
+  "scan_token_drift",
+  "get_conventions",
+  "set_conventions",
+  // Components
+  "get_local_components",
+  "get_instance_overrides",
+  "set_instance_overrides",
+  "create_component",
+  "create_component_set",
+  "get_component_properties",
+  "set_component_properties",
+  "detach_instance",
+  "reset_instance",
+  "audit_colors",
+  "find_orphan_instances",
+  // Variables
+  "get_variable_collections",
+  "get_variables",
+  "create_variable_collection",
+  "create_variable",
+  "update_variable",
+  "delete_variable",
+  "delete_variable_collection",
+  "update_variable_collection",
+  "add_mode",
+  "remove_mode",
+  "rename_mode",
+  "set_variable_scopes",
+  "set_variable_code_syntax",
+  "remove_variable_code_syntax",
+  "create_variable_alias",
+  "bind_variable",
+  "unbind_variable",
+  "set_node_variable_mode",
+  "get_resolved_variable_modes",
+  // Styles
+  "get_styles",
+  "create_paint_style",
+  "create_text_style",
+  "create_effect_style",
+  "create_grid_style",
+  "update_style",
+  "delete_style",
+  "apply_style",
+  "reorder_style",
+  // Export
+  "export_node_as_image",
+  "get_screenshot",
+  "create_image_from_url",
+  // Page
+  "get_pages",
+  "create_page",
+  "rename_page",
+  "delete_page",
+  "switch_page",
+  "set_page_background",
+  "get_flow_starting_points",
+  // Structure
+  "group_nodes",
+  "ungroup_nodes",
+  "flatten_node",
+  "boolean_operation",
+  "create_component_from_node",
+  // Library
+  "import_component_by_key",
+  "import_style_by_key",
+  "import_variable_by_key",
+  // Document extras
+  "get_selection_colors",
+  "set_file_thumbnail",
+  "figma_notify",
+  // Constraints
+  "set_constraints",
+  "set_min_max_size",
+  // Annotations
+  "get_annotations",
+  "set_annotation",
+  "set_multiple_annotations",
+  // Prototype
+  "get_reactions",
+  "set_default_connector",
+  "create_connections",
+  // Viewport
+  "set_focus",
+  "set_selections",
+  "get_viewport",
+  "set_viewport",
+  // Plugin data
+  "set_plugin_data",
+  "get_plugin_data",
+  // Image fill
+  "set_image_fill",
+  // Batch
+  "batch_execute",
+  "execute_code",
+  // Room
+  "join"
+];
+
+// ../shared/src/pitfalls.ts
+var PITFALLS = [
+  {
+    pattern: "unloaded font",
+    hint: "await figma.loadFontAsync(node.fontName) before editing text \u2014 new TextNodes default to Inter Regular; for mixed ranges load every font from getRangeAllFontNames().",
+    doc: "**Editing text without loading its font throws** (`unloaded font`). `await figma.loadFontAsync(textNode.fontName)` first; new TextNodes default to Inter Regular; when `fontName === figma.mixed`, load every font from `getRangeAllFontNames()`."
+  },
+  {
+    pattern: "getNodeById",
+    hint: "This plugin runs in dynamic-page mode \u2014 use await figma.getNodeByIdAsync(id) instead of getNodeById.",
+    doc: "**`getNodeById` throws in dynamic-page mode** \u2014 always `await figma.getNodeByIdAsync(id)`."
+  },
+  {
+    pattern: "explicitly loaded",
+    hint: "Non-current pages must be loaded before traversal: await page.loadAsync() before reading page.children or calling findAll.",
+    doc: "**Traversing a non-current page throws until you `await page.loadAsync()`** \u2014 `figma.currentPage` is always loaded, other pages are not."
+  },
+  {
+    pattern: "layoutSizing",
+    hint: "layoutSizing FILL/HUG needs auto-layout \u2014 on the parent for FILL, on the node itself for HUG. Set layoutMode on the frame first.",
+    doc: "**`layoutSizingHorizontal/Vertical` throw without auto-layout** \u2014 FILL requires the parent to have a `layoutMode`, HUG requires it on the node itself."
+  },
+  {
+    pattern: "Starter plan",
+    hint: "This file hit the free-plan page limit \u2014 reuse an existing page (find it via figma.root.children) instead of figma.createPage().",
+    doc: "**`createPage()` throws on the free plan once a file has 3 pages** \u2014 reuse an existing page instead."
+  },
+  {
+    pattern: "read.?only property '(width|height)'",
+    hint: "width/height are read-only \u2014 use node.resize(w, h) (and note resize on an auto-layout frame pins that axis to FIXED).",
+    doc: "**`width`/`height` are read-only** \u2014 use `node.resize(w, h)`."
+  },
+  {
+    pattern: "symbol",
+    hint: "You probably hit figma.mixed (a Symbol) \u2014 properties like fontSize/cornerRadius/fills return it when values differ across ranges or children. Compare with === figma.mixed before using the value.",
+    doc: "**`figma.mixed` is a Symbol** returned by `fontSize`, `cornerRadius`, `fills` etc. when values differ across ranges/children \u2014 check `=== figma.mixed` before use; never JSON-serialize it."
+  },
+  {
+    pattern: "of undefined",
+    hint: 'A lookup returned undefined \u2014 if you searched pages or nodes by exact name, names may have been changed by the designer. Locate by type/content (e.g. c.type === "COMPONENT_SET") instead.',
+    doc: "**Exact-name lookups are fragile** \u2014 designers rename pages and layers freely; locate nodes by type/content instead of `name ===`."
+  },
+  {
+    pattern: "does not exist",
+    hint: "The node id is stale \u2014 the node was likely deleted or lives on another page. Re-read the document to get current ids.",
+    doc: "**Stale node ids throw `does not exist`** \u2014 nodes get deleted while you work; re-read before editing and check `node.removed`."
+  },
+  {
+    pattern: "not extensible",
+    hint: "Figma nodes can't hold custom properties (they're non-extensible). Stash data with node.setPluginData(key, value), or return it from the script.",
+    doc: "**Nodes are non-extensible** \u2014 `node.myCustomProp = x` throws `object is not extensible`; use `setPluginData` or return the data instead."
+  },
+  // ── silent pitfalls: nothing throws, results are just wrong ──
+  {
+    pattern: null,
+    hint: "",
+    doc: "**Shadow `spread` renders only on shapes or frames with `clipsContent: true`** \u2014 a focus ring built from spread shadows is invisible on a non-clipping frame/component."
+  },
+  {
+    pattern: null,
+    hint: "",
+    doc: '**`resize()` on an auto-layout frame silently pins that axis to FIXED**, overriding `primaryAxisSizingMode: "AUTO"`. Append children first, then set `layoutSizingHorizontal = "HUG"`; use `resize` only for the fixed cross-axis.'
+  },
+  {
+    pattern: null,
+    hint: "",
+    doc: "**Per-corner radius** (`topLeftRadius` \u2026) only exists on RectangleCornerMixin nodes (rectangles, frames, components) \u2014 polygons, stars and lines throw."
+  },
+  {
+    pattern: null,
+    hint: "",
+    doc: "**Instance children can't be added or removed** \u2014 detach first, or edit the main component."
+  }
+];
+
+// ../shared/src/utils/color.ts
+function rgbaToHex(color) {
+  const r = Math.round(color.r * 255);
+  const g = Math.round(color.g * 255);
+  const b = Math.round(color.b * 255);
+  const hex = `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+  if (color.a !== void 0 && color.a < 1) {
+    const a = Math.round(color.a * 255);
+    return hex + a.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+
+// ../shared/src/utils/schemas.ts
+import { z } from "zod";
+var colorSchema = z.object({
+  r: z.number().min(0).max(1).describe("Red channel (0-1)"),
+  g: z.number().min(0).max(1).describe("Green channel (0-1)"),
+  b: z.number().min(0).max(1).describe("Blue channel (0-1)"),
+  a: z.number().min(0).max(1).optional().describe("Alpha channel (0-1)")
+});
+var dimensionSchema = z.number().positive();
+var layoutModeSchema = z.enum(["NONE", "HORIZONTAL", "VERTICAL"]);
+var layoutWrapSchema = z.enum(["NO_WRAP", "WRAP"]);
+var primaryAxisAlignSchema = z.enum([
+  "MIN",
+  "MAX",
+  "CENTER",
+  "SPACE_BETWEEN"
+]);
+var counterAxisAlignSchema = z.enum([
+  "MIN",
+  "MAX",
+  "CENTER",
+  "BASELINE"
+]);
+var sizingModeSchema = z.enum(["FIXED", "HUG", "FILL"]);
+var exportFormatSchema = z.enum(["PNG", "JPG", "SVG", "PDF"]);
+var blendModeSchema = z.enum([
+  "PASS_THROUGH",
+  "NORMAL",
+  "DARKEN",
+  "MULTIPLY",
+  "LINEAR_BURN",
+  "COLOR_BURN",
+  "LIGHTEN",
+  "SCREEN",
+  "LINEAR_DODGE",
+  "COLOR_DODGE",
+  "OVERLAY",
+  "SOFT_LIGHT",
+  "HARD_LIGHT",
+  "DIFFERENCE",
+  "EXCLUSION",
+  "HUE",
+  "SATURATION",
+  "COLOR",
+  "LUMINOSITY"
+]);
+var gradientTypeSchema = z.enum([
+  "GRADIENT_LINEAR",
+  "GRADIENT_RADIAL",
+  "GRADIENT_ANGULAR",
+  "GRADIENT_DIAMOND"
+]);
+var gradientStopSchema = z.object({
+  position: z.number().min(0).max(1).describe("Stop position (0-1)"),
+  color: colorSchema
+});
+var booleanOperationSchema = z.enum([
+  "UNION",
+  "SUBTRACT",
+  "INTERSECT",
+  "EXCLUDE"
+]);
+var constraintTypeSchema = z.enum([
+  "MIN",
+  "CENTER",
+  "MAX",
+  "STRETCH",
+  "SCALE"
+]);
+var reorderDirectionSchema = z.enum([
+  "FRONT",
+  "BACK",
+  "FORWARD",
+  "BACKWARD"
+]);
+
+// ../shared/src/relay-core.ts
+var RelayCore = class {
+  rooms = /* @__PURE__ */ new Map();
+  lastActivity = /* @__PURE__ */ new Map();
+  staleTimer = null;
+  version;
+  log;
+  constructor(options = {}) {
+    this.version = options.version ?? "unknown";
+    this.log = options.log ?? (() => {
+    });
+  }
+  handleOpen(ws) {
+    this.lastActivity.set(ws, Date.now());
+    this.send(ws, { type: "system", message: "Please join a room to start" });
+  }
+  handleMessage(ws, raw) {
+    this.lastActivity.set(ws, Date.now());
+    let data;
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      this.send(ws, { type: "error", message: "Invalid JSON" });
+      return;
+    }
+    switch (data.type) {
+      case "hello":
+        this.send(ws, { type: "hello", server: "figma-relai", version: this.version });
+        return;
+      case "join": {
+        const room = data.room;
+        if (!room || typeof room !== "string") {
+          this.send(ws, { type: "error", message: "Room name required" });
+          return;
+        }
+        const role = data.role === "plugin" || data.role === "agent" ? data.role : "unknown";
+        const peers = this.roomPeers(room);
+        peers.set(ws, { role, meta: data.meta });
+        this.log(`Client joined "${room}" as ${role} (${peers.size} clients)`);
+        this.send(ws, { type: "system", message: `Joined room: ${room}`, room });
+        this.send(ws, {
+          type: "system",
+          message: { id: data.id, result: `Connected to room: ${room}` },
+          room
+        });
+        this.broadcastPresence(room);
+        return;
+      }
+      case "list_rooms": {
+        const rooms = [];
+        for (const [room, peers] of this.rooms) {
+          if (peers.size === 0) continue;
+          const pluginPeer = [...peers.values()].find((p) => p.role === "plugin");
+          const fileName = typeof pluginPeer?.meta?.fileName === "string" ? pluginPeer.meta.fileName : void 0;
+          rooms.push({
+            room,
+            hasPlugin: pluginPeer !== void 0,
+            agentCount: [...peers.values()].filter((p) => p.role === "agent").length,
+            ...fileName ? { fileName } : {}
+          });
+        }
+        this.send(ws, { type: "list_rooms_result", id: data.id, rooms });
+        return;
+      }
+      case "message": {
+        const room = data.room;
+        if (!room || typeof room !== "string") {
+          this.send(ws, { type: "error", message: "Room name required" });
+          return;
+        }
+        if (!this.rooms.get(room)?.has(ws)) {
+          this.send(ws, { type: "error", message: "Must join room first" });
+          return;
+        }
+        const payload = JSON.stringify({
+          type: "broadcast",
+          message: data.message,
+          sender: "peer",
+          room
+        });
+        const count = this.broadcast(ws, room, payload);
+        if (count === 0) this.log(`No peers in "${room}" to receive message`);
+        return;
+      }
+      case "progress_update": {
+        const room = data.room;
+        if (room && typeof room === "string" && this.rooms.get(room)?.has(ws)) {
+          this.broadcast(ws, room, raw);
+        }
+        return;
+      }
+    }
+  }
+  handleClose(ws) {
+    this.lastActivity.delete(ws);
+    const affected = [];
+    for (const [room, peers] of this.rooms) {
+      if (peers.delete(ws)) affected.push(room);
+      if (peers.size === 0) this.rooms.delete(room);
+    }
+    for (const room of affected) this.broadcastPresence(room);
+  }
+  // Periodically close connections with no activity (heartbeat)
+  startStaleCleanup(staleTimeoutMs = 12e4, checkIntervalMs = 3e4) {
+    this.staleTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [ws, lastTime] of this.lastActivity) {
+        if (now - lastTime > staleTimeoutMs) {
+          this.log("Closing stale connection");
+          try {
+            ws.close();
+          } catch {
+          }
+          this.handleClose(ws);
+        }
+      }
+    }, checkIntervalMs);
+  }
+  stop() {
+    if (this.staleTimer) {
+      clearInterval(this.staleTimer);
+      this.staleTimer = null;
+    }
+  }
+  roomPeers(room) {
+    let peers = this.rooms.get(room);
+    if (!peers) {
+      peers = /* @__PURE__ */ new Map();
+      this.rooms.set(room, peers);
+    }
+    return peers;
+  }
+  // Presence goes to every member (including the newcomer) so both the plugin
+  // UI and the MCP server always know who is in the room
+  broadcastPresence(room) {
+    const peers = this.rooms.get(room);
+    if (!peers) return;
+    const payload = JSON.stringify({
+      type: "presence",
+      room,
+      peers: [...peers.values()].map((p) => ({ role: p.role, meta: p.meta }))
+    });
+    for (const ws of peers.keys()) {
+      try {
+        ws.send(payload);
+      } catch {
+      }
+    }
+  }
+  broadcast(sender, room, payload) {
+    const peers = this.rooms.get(room);
+    if (!peers) return 0;
+    let count = 0;
+    for (const ws of peers.keys()) {
+      if (ws === sender) continue;
+      try {
+        ws.send(payload);
+        count++;
+      } catch {
+      }
+    }
+    return count;
+  }
+  send(ws, data) {
+    try {
+      ws.send(JSON.stringify(data));
+    } catch {
+    }
+  }
+};
+
+// src/tools/index.ts
+import { z as z22 } from "zod";
+
+// src/tools/core/create.ts
+var create_exports = {};
+__export(create_exports, {
+  register: () => register
+});
+import { z as z2 } from "zod";
+
+// src/tools/core/helpers.ts
+function textResult(text) {
+  return { content: [{ type: "text", text }] };
+}
+function jsonResult(value) {
+  return textResult(typeof value === "string" ? value : JSON.stringify(value, null, 2));
+}
+function errorResult(error) {
+  return textResult(`Error: ${error instanceof Error ? error.message : String(error)}`);
+}
+
+// src/tools/core/create.ts
+var NODE_KINDS = [
+  "rectangle",
+  "frame",
+  "text",
+  "ellipse",
+  "polygon",
+  "star",
+  "line",
+  "section",
+  "slice",
+  "svg",
+  "image",
+  "connector",
+  "table",
+  "sticky",
+  "code_block"
+];
+var KIND_COMMAND = {
+  rectangle: "create_rectangle",
+  frame: "create_frame",
+  text: "create_text",
+  ellipse: "create_ellipse",
+  polygon: "create_polygon",
+  star: "create_star",
+  line: "create_line",
+  section: "create_section",
+  slice: "create_slice",
+  svg: "create_node_from_svg",
+  image: "create_image_from_url",
+  connector: "create_connector",
+  table: "create_table",
+  sticky: "create_sticky",
+  code_block: "create_code_block"
+};
+function register(server, sendCommand) {
+  server.tool(
+    "create_node",
+    "Create a node in Figma: rectangle, frame, text, ellipse, polygon, star, line, section, slice, svg (from markup), image (from URL), or FigJam connector/table/sticky/code_block. Returns the new node's id \u2014 style it further with set_properties. For component instances use manage_components.",
+    {
+      type: z2.enum(NODE_KINDS).describe("What to create"),
+      x: z2.number().optional().describe("X position (default 0)"),
+      y: z2.number().optional().describe("Y position (default 0)"),
+      width: dimensionSchema.optional(),
+      height: dimensionSchema.optional(),
+      name: z2.string().optional(),
+      parentId: z2.string().optional().describe("Parent node id (default: current page)"),
+      text: z2.string().optional().describe("Text content (text/sticky)"),
+      fontSize: z2.number().positive().optional().describe("text only"),
+      fontWeight: z2.number().optional().describe("text only (e.g. 400, 700)"),
+      fontColor: colorSchema.optional().describe("text only"),
+      fillColor: colorSchema.optional().describe("frame/rectangle fill"),
+      pointCount: z2.number().int().min(3).optional().describe("polygon/star points"),
+      innerRadius: z2.number().min(0).max(1).optional().describe("star inner radius ratio"),
+      length: z2.number().positive().optional().describe("line length"),
+      rotation: z2.number().optional().describe("line rotation in degrees"),
+      strokeWeight: z2.number().min(0).optional().describe("line stroke weight"),
+      svg: z2.string().optional().describe("SVG markup (type=svg)"),
+      url: z2.string().optional().describe("Image URL (type=image)"),
+      scaleMode: z2.enum(["FILL", "FIT", "CROP", "TILE"]).optional().describe("image only"),
+      rows: z2.number().int().positive().optional().describe("table only"),
+      cols: z2.number().int().positive().optional().describe("table only"),
+      startNodeId: z2.string().optional().describe("connector only"),
+      endNodeId: z2.string().optional().describe("connector only"),
+      lineType: z2.enum(["ELBOWED", "STRAIGHT"]).optional().describe("connector only")
+    },
+    async ({ type, ...params }) => {
+      try {
+        const clean = Object.fromEntries(
+          Object.entries(params).filter(([, v]) => v !== void 0)
+        );
+        const result = await sendCommand(KIND_COMMAND[type], clean);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/properties.ts
+var properties_exports = {};
+__export(properties_exports, {
+  mapPropertiesToCommands: () => mapPropertiesToCommands,
+  propertiesSchema: () => propertiesSchema,
+  register: () => register2
+});
+import { z as z3 } from "zod";
+var effectSchema = z3.object({
+  type: z3.enum(["DROP_SHADOW", "INNER_SHADOW", "LAYER_BLUR", "BACKGROUND_BLUR"]),
+  color: colorSchema.optional().describe("Shadow color (shadows only)"),
+  offsetX: z3.number().optional(),
+  offsetY: z3.number().optional(),
+  radius: z3.number().min(0).optional().describe("Blur radius"),
+  spread: z3.number().optional()
+});
+var propertiesSchema = z3.object({
+  // Geometry
+  x: z3.number().optional(),
+  y: z3.number().optional(),
+  width: dimensionSchema.optional(),
+  height: dimensionSchema.optional(),
+  rotation: z3.number().optional().describe("Degrees"),
+  // Identity / visibility
+  name: z3.string().optional(),
+  visible: z3.boolean().optional(),
+  locked: z3.boolean().optional(),
+  opacity: z3.number().min(0).max(1).optional(),
+  blendMode: blendModeSchema.optional(),
+  // Paint
+  fillColor: colorSchema.optional(),
+  fills: z3.array(z3.record(z3.unknown())).optional().describe("Raw Paint[] \u2014 replaces the whole fill list; [] clears all fills"),
+  strokes: z3.array(z3.record(z3.unknown())).optional().describe("Raw Paint[] \u2014 replaces the whole stroke list; [] clears all strokes"),
+  strokeColor: colorSchema.optional(),
+  strokeWeight: z3.number().min(0).optional(),
+  cornerRadius: z3.number().min(0).optional(),
+  corners: z3.array(z3.boolean()).length(4).optional().describe("With cornerRadius: apply per corner [TL, TR, BR, BL]"),
+  gradient: z3.object({ gradientType: gradientTypeSchema, stops: z3.array(gradientStopSchema).min(2) }).optional(),
+  // Effects (replaces existing effects list entry of same type)
+  effects: z3.array(effectSchema).optional(),
+  removeEffects: z3.boolean().optional(),
+  // Text
+  text: z3.string().optional().describe("Text content (TEXT nodes)"),
+  // Auto-layout (frame itself)
+  layoutMode: layoutModeSchema.optional(),
+  layoutWrap: layoutWrapSchema.optional().describe("WRAP requires layoutMode HORIZONTAL"),
+  paddingTop: z3.number().min(0).optional(),
+  paddingRight: z3.number().min(0).optional(),
+  paddingBottom: z3.number().min(0).optional(),
+  paddingLeft: z3.number().min(0).optional(),
+  primaryAxisAlignItems: primaryAxisAlignSchema.optional(),
+  counterAxisAlignItems: counterAxisAlignSchema.optional(),
+  itemSpacing: z3.number().optional(),
+  counterAxisSpacing: z3.number().optional(),
+  // Auto-layout (as a child; FILL requires the PARENT to have auto-layout)
+  layoutSizingHorizontal: sizingModeSchema.optional(),
+  layoutSizingVertical: sizingModeSchema.optional(),
+  // Constraints & sizing limits
+  constraintsHorizontal: constraintTypeSchema.optional(),
+  constraintsVertical: constraintTypeSchema.optional(),
+  minWidth: z3.number().min(0).optional(),
+  maxWidth: z3.number().min(0).optional(),
+  minHeight: z3.number().min(0).optional(),
+  maxHeight: z3.number().min(0).optional(),
+  aspectRatioLocked: z3.boolean().optional(),
+  clipsContent: z3.boolean().optional(),
+  // Design-system bindings
+  styleId: z3.string().optional().describe("Apply a paint/text/effect/grid style by id"),
+  styleType: z3.enum(["PAINT", "TEXT", "EFFECT", "GRID"]).optional(),
+  boundVariables: z3.record(z3.string()).optional().describe('Bind variables: {"fills": "VariableID:...", "width": "..."}')
+}).strict();
+function defined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== void 0));
+}
+function mapPropertiesToCommands(nodeId, p) {
+  const calls = [];
+  const add = (command, params) => calls.push({ command, params: { nodeId, ...defined(params) } });
+  if (p.name !== void 0) add("rename_node", { name: p.name });
+  if (p.visible !== void 0) add("set_visible", { visible: p.visible });
+  if (p.locked !== void 0) add("set_locked", { locked: p.locked });
+  if (p.x !== void 0 || p.y !== void 0) add("move_node", { x: p.x, y: p.y });
+  if (p.width !== void 0 || p.height !== void 0)
+    add("resize_node", { width: p.width, height: p.height });
+  if (p.rotation !== void 0) add("set_rotation", { rotation: p.rotation });
+  if (p.layoutMode !== void 0)
+    add("set_layout_mode", { layoutMode: p.layoutMode, layoutWrap: p.layoutWrap });
+  if (p.paddingTop !== void 0 || p.paddingRight !== void 0 || p.paddingBottom !== void 0 || p.paddingLeft !== void 0)
+    add("set_padding", {
+      paddingTop: p.paddingTop,
+      paddingRight: p.paddingRight,
+      paddingBottom: p.paddingBottom,
+      paddingLeft: p.paddingLeft
+    });
+  if (p.primaryAxisAlignItems !== void 0 || p.counterAxisAlignItems !== void 0)
+    add("set_axis_align", {
+      primaryAxisAlignItems: p.primaryAxisAlignItems,
+      counterAxisAlignItems: p.counterAxisAlignItems
+    });
+  if (p.itemSpacing !== void 0 || p.counterAxisSpacing !== void 0)
+    add("set_item_spacing", {
+      itemSpacing: p.itemSpacing,
+      counterAxisSpacing: p.counterAxisSpacing
+    });
+  if (p.layoutSizingHorizontal !== void 0 || p.layoutSizingVertical !== void 0)
+    add("set_layout_sizing", {
+      layoutSizingHorizontal: p.layoutSizingHorizontal,
+      layoutSizingVertical: p.layoutSizingVertical
+    });
+  if (p.fills !== void 0 || p.strokes !== void 0)
+    add("set_fills", {
+      ...p.fills !== void 0 ? { fills: p.fills } : {},
+      ...p.strokes !== void 0 ? { strokes: p.strokes } : {}
+    });
+  if (p.fillColor !== void 0) add("set_fill_color", { color: p.fillColor });
+  if (p.strokeColor !== void 0 || p.strokeWeight !== void 0)
+    add("set_stroke_color", {
+      color: p.strokeColor ?? { r: 0, g: 0, b: 0, a: 1 },
+      weight: p.strokeWeight
+    });
+  if (p.gradient !== void 0)
+    add("set_gradient_fill", { gradientType: p.gradient.gradientType, stops: p.gradient.stops });
+  if (p.cornerRadius !== void 0)
+    add("set_corner_radius", { radius: p.cornerRadius, corners: p.corners });
+  if (p.opacity !== void 0) add("set_opacity", { opacity: p.opacity });
+  if (p.blendMode !== void 0) add("set_blend_mode", { blendMode: p.blendMode });
+  if (p.removeEffects) add("remove_effects", {});
+  for (const effect of p.effects ?? []) {
+    const common = {
+      color: effect.color,
+      offsetX: effect.offsetX,
+      offsetY: effect.offsetY,
+      radius: effect.radius,
+      spread: effect.spread
+    };
+    if (effect.type === "DROP_SHADOW") add("add_drop_shadow", common);
+    else if (effect.type === "INNER_SHADOW") add("add_inner_shadow", common);
+    else if (effect.type === "LAYER_BLUR") add("add_blur", { radius: effect.radius });
+    else add("add_background_blur", { radius: effect.radius });
+  }
+  if (p.text !== void 0) add("set_text_content", { text: p.text });
+  if (p.constraintsHorizontal !== void 0 || p.constraintsVertical !== void 0)
+    add("set_constraints", {
+      horizontal: p.constraintsHorizontal,
+      vertical: p.constraintsVertical
+    });
+  if (p.minWidth !== void 0 || p.maxWidth !== void 0 || p.minHeight !== void 0 || p.maxHeight !== void 0)
+    add("set_min_max_size", {
+      minWidth: p.minWidth,
+      maxWidth: p.maxWidth,
+      minHeight: p.minHeight,
+      maxHeight: p.maxHeight
+    });
+  if (p.aspectRatioLocked !== void 0) add("set_aspect_ratio", { lock: p.aspectRatioLocked });
+  if (p.clipsContent !== void 0) add("set_clips_content", { clipsContent: p.clipsContent });
+  if (p.styleId !== void 0)
+    add("apply_style", { styleId: p.styleId, styleType: p.styleType });
+  for (const [property, variableId] of Object.entries(p.boundVariables ?? {})) {
+    add("bind_variable", { property, variableId });
+  }
+  return calls;
+}
+function register2(server, sendCommand) {
+  server.tool(
+    "set_properties",
+    "Set any visual/layout/text properties on one or more nodes in a single call: geometry (x/y/width/height/rotation), fills/strokes/gradients/cornerRadius/opacity/effects, text content, auto-layout (layoutMode, padding, alignment, spacing, layoutSizing \u2014 FILL requires the parent to have auto-layout), constraints, style application, and variable bindings. Groups map to focused operations with per-operation success/error reporting. dryRun:true previews the mapped command list without touching the canvas.",
+    {
+      nodeIds: z3.array(z3.string()).min(1).describe("Node IDs to update"),
+      properties: propertiesSchema.describe("Properties to apply to every listed node"),
+      dryRun: z3.boolean().optional().describe("Preview only \u2014 return the plan, execute nothing")
+    },
+    { idempotentHint: true },
+    async ({ nodeIds, properties, dryRun }) => {
+      try {
+        const commands = nodeIds.flatMap(
+          (nodeId) => mapPropertiesToCommands(nodeId, properties)
+        );
+        if (commands.length === 0) return textResult("No properties given \u2014 nothing to do.");
+        if (dryRun) {
+          return jsonResult({
+            dryRun: true,
+            commandCount: commands.length,
+            commands,
+            note: "Nothing was executed. Re-run without dryRun to apply."
+          });
+        }
+        if (commands.length === 1) {
+          const result = await sendCommand(commands[0].command, commands[0].params);
+          return jsonResult(result);
+        }
+        const results = await sendCommand(
+          "batch_execute",
+          { commands },
+          Math.max(3e4, commands.length * 5e3)
+        );
+        return jsonResult(results);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/structure.ts
+var structure_exports = {};
+__export(structure_exports, {
+  register: () => register3
+});
+import { z as z4 } from "zod";
+function register3(server, sendCommand) {
+  server.tool(
+    "edit_structure",
+    "Structural operations on nodes: group/ungroup, reparent (move into another parent), reorder (z-order), clone, flatten to vector, boolean operations (union/subtract/intersect/exclude), delete. group/boolean/delete take nodeIds; the rest take nodeId.",
+    {
+      operation: z4.enum([
+        "group",
+        "ungroup",
+        "reparent",
+        "reorder",
+        "clone",
+        "flatten",
+        "boolean",
+        "delete"
+      ]),
+      nodeId: z4.string().optional().describe("Target node (ungroup/reparent/reorder/clone/flatten)"),
+      nodeIds: z4.array(z4.string()).optional().describe("Target nodes (group/boolean/delete)"),
+      parentId: z4.string().optional().describe("reparent: new parent"),
+      index: z4.number().int().min(0).optional().describe("reparent: insertion index"),
+      direction: reorderDirectionSchema.optional().describe("reorder direction"),
+      booleanOperation: booleanOperationSchema.optional().describe("boolean: which operation"),
+      x: z4.number().optional().describe("clone: position of the copy"),
+      y: z4.number().optional()
+    },
+    async ({ operation, nodeId, nodeIds, parentId, index, direction, booleanOperation, x, y }) => {
+      try {
+        const need = (value, what) => {
+          if (value === void 0) throw new Error(`"${operation}" requires ${what}`);
+        };
+        let result;
+        switch (operation) {
+          case "group":
+            need(nodeIds, "nodeIds");
+            result = await sendCommand("group_nodes", { nodeIds });
+            break;
+          case "ungroup":
+            need(nodeId, "nodeId");
+            result = await sendCommand("ungroup_nodes", { nodeId });
+            break;
+          case "reparent":
+            need(nodeId, "nodeId");
+            need(parentId, "parentId");
+            result = await sendCommand("reparent_node", { nodeId, parentId, index });
+            break;
+          case "reorder":
+            need(nodeId, "nodeId");
+            need(direction, "direction");
+            result = await sendCommand("reorder_node", { nodeId, direction });
+            break;
+          case "clone":
+            need(nodeId, "nodeId");
+            result = await sendCommand("clone_node", { nodeId, x, y });
+            break;
+          case "flatten":
+            need(nodeId, "nodeId");
+            result = await sendCommand("flatten_node", { nodeId });
+            break;
+          case "boolean":
+            need(nodeIds, "nodeIds");
+            need(booleanOperation, "booleanOperation");
+            result = await sendCommand("boolean_operation", {
+              nodeIds,
+              operation: booleanOperation
+            });
+            break;
+          case "delete":
+            if (nodeIds) result = await sendCommand("delete_multiple_nodes", { nodeIds });
+            else {
+              need(nodeId, "nodeId or nodeIds");
+              result = await sendCommand("delete_node", { nodeId });
+            }
+            break;
+        }
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/text.ts
+var text_exports = {};
+__export(text_exports, {
+  register: () => register4
+});
+import { z as z5 } from "zod";
+function register4(server, sendCommand) {
+  server.tool(
+    "set_text",
+    "Edit text nodes. Modes: single (nodeId + text), bulk (items \u2014 efficient for many nodes, e.g. translations), or character-range styling (nodeId + range with fontSize/fontWeight/letterSpacing/lineHeight). Fonts load automatically with fallbacks. To find text nodes first, use search_nodes or get_selection_context.",
+    {
+      nodeId: z5.string().optional().describe("Target text node (single / range mode)"),
+      text: z5.string().optional().describe("New content (single mode)"),
+      items: z5.array(z5.object({ nodeId: z5.string(), text: z5.string() })).optional().describe("Bulk replacements"),
+      range: z5.object({
+        start: z5.number().int().min(0),
+        end: z5.number().int().positive(),
+        fontSize: z5.number().positive().optional(),
+        fontWeight: z5.number().optional(),
+        letterSpacing: z5.number().optional(),
+        lineHeight: z5.number().optional()
+      }).refine((r) => r.end > r.start, { message: "end must be greater than start" }).optional().describe("Style a character range [start, end)")
+    },
+    async ({ nodeId, text, items, range }) => {
+      try {
+        if (items?.length) {
+          const result = await sendCommand(
+            "set_multiple_text_contents",
+            { text: items },
+            Math.max(3e4, items.length * 2e3)
+          );
+          return jsonResult(result);
+        }
+        if (nodeId && range) {
+          const result = await sendCommand("set_text_style_range", { nodeId, ...range });
+          return jsonResult(result);
+        }
+        if (nodeId && text !== void 0) {
+          const result = await sendCommand("set_text_content", { nodeId, text });
+          return jsonResult(result);
+        }
+        return textResult(
+          "Provide either items (bulk), nodeId + text (single), or nodeId + range (styling)."
+        );
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/components.ts
+var components_exports = {};
+__export(components_exports, {
+  register: () => register5
+});
+import { z as z6 } from "zod";
+function register5(server, sendCommand) {
+  server.tool(
+    "manage_components",
+    "Component workflow: list local components, create a component from a node, create_set (combine components as variants), instantiate (place an instance by componentKey \u2014 imports from the team library if needed), get_props / set_props (component properties on an instance), get_overrides / set_overrides (copy overrides from a source instance to targets), reset_instance (clear ALL overrides so the instance re-inherits its main component \u2014 returns property snapshots before/after so you can re-apply what mattered), detach.",
+    {
+      action: z6.enum([
+        "list",
+        "create",
+        "create_set",
+        "instantiate",
+        "get_props",
+        "set_props",
+        "get_overrides",
+        "set_overrides",
+        "reset_instance",
+        "detach"
+      ]),
+      nodeId: z6.string().optional().describe("Target node (create/get_props/set_props/reset_instance/detach)"),
+      componentIds: z6.array(z6.string()).optional().describe("create_set: components to combine"),
+      componentKey: z6.string().optional().describe("instantiate: component key (or node id)"),
+      x: z6.number().optional().describe("instantiate: position"),
+      y: z6.number().optional(),
+      properties: z6.record(z6.union([z6.string(), z6.boolean()])).optional().describe("set_props: property name \u2192 value (variant/text/boolean/swap)"),
+      sourceInstanceId: z6.string().optional().describe("set_overrides: copy from this instance"),
+      targetNodeIds: z6.array(z6.string()).optional().describe("set_overrides: apply to these"),
+      instanceNodeId: z6.string().optional().describe("get_overrides: instance to inspect")
+    },
+    async (args) => {
+      try {
+        let result;
+        switch (args.action) {
+          case "list":
+            result = await sendCommand("get_local_components", {}, 6e4);
+            break;
+          case "create":
+            result = await sendCommand("create_component_from_node", { nodeId: args.nodeId });
+            break;
+          case "create_set":
+            result = await sendCommand("create_component_set", { componentIds: args.componentIds });
+            break;
+          case "instantiate":
+            result = await sendCommand("create_component_instance", {
+              componentKey: args.componentKey,
+              x: args.x,
+              y: args.y
+            });
+            break;
+          case "get_props":
+            result = await sendCommand("get_component_properties", { nodeId: args.nodeId });
+            break;
+          case "set_props":
+            result = await sendCommand("set_component_properties", {
+              nodeId: args.nodeId,
+              properties: args.properties
+            });
+            break;
+          case "get_overrides":
+            result = await sendCommand("get_instance_overrides", {
+              instanceNodeId: args.instanceNodeId ?? args.nodeId
+            });
+            break;
+          case "set_overrides":
+            result = await sendCommand("set_instance_overrides", {
+              sourceInstanceId: args.sourceInstanceId,
+              targetNodeIds: args.targetNodeIds
+            });
+            break;
+          case "reset_instance":
+            result = await sendCommand("reset_instance", { nodeId: args.nodeId });
+            break;
+          case "detach":
+            result = await sendCommand("detach_instance", { nodeId: args.nodeId });
+            break;
+        }
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/variables.ts
+var variables_exports = {};
+__export(variables_exports, {
+  register: () => register6
+});
+import { z as z7 } from "zod";
+var ACTIONS = {
+  list_collections: ["get_variable_collections", []],
+  list: ["get_variables", ["collectionId"]],
+  create_collection: ["create_variable_collection", ["name", "modes"]],
+  update_collection: ["update_variable_collection", ["collectionId", "name", "hiddenFromPublishing"]],
+  delete_collection: ["delete_variable_collection", ["collectionId"]],
+  create: ["create_variable", ["collectionId", "name", "resolvedType", "value"]],
+  update: ["update_variable", ["variableId", "modeId", "value", "name", "description", "hiddenFromPublishing"]],
+  delete: ["delete_variable", ["variableId"]],
+  add_mode: ["add_mode", ["collectionId", "name"]],
+  remove_mode: ["remove_mode", ["collectionId", "modeId"]],
+  rename_mode: ["rename_mode", ["collectionId", "modeId", "name"]],
+  set_scopes: ["set_variable_scopes", ["variableId", "scopes"]],
+  set_code_syntax: ["set_variable_code_syntax", ["variableId", "platform", "value"]],
+  remove_code_syntax: ["remove_variable_code_syntax", ["variableId", "platform"]],
+  create_alias: ["create_variable_alias", ["variableId", "targetVariableId", "modeId"]],
+  bind: ["bind_variable", ["nodeId", "variableId", "property"]],
+  unbind: ["unbind_variable", ["nodeId", "property"]],
+  set_node_mode: ["set_node_variable_mode", ["nodeId", "collectionId", "modeId"]],
+  get_node_modes: ["get_resolved_variable_modes", ["nodeId"]],
+  tokenize: ["scan_token_drift", ["nodeId", "fix", "tolerance"]]
+};
+function register6(server, sendCommand) {
+  server.tool(
+    "manage_variables",
+    "Design-token variables: list_collections / list (variables in a collection) / create_collection / update_collection / delete_collection / create / update / delete / add_mode / remove_mode / rename_mode / set_scopes / set_code_syntax / remove_code_syntax / create_alias / bind (variable\u2192node property) / unbind / set_node_mode / get_node_modes / tokenize (find hardcoded colors & numbers that match existing variables and bind them \u2014 fix:false to preview, fix:true to apply; scope with nodeId, default current page). Pass only the fields the action needs.",
+    {
+      action: z7.enum(Object.keys(ACTIONS)),
+      collectionId: z7.string().optional(),
+      variableId: z7.string().optional(),
+      targetVariableId: z7.string().optional().describe("create_alias: variable to alias to"),
+      nodeId: z7.string().optional().describe("bind/unbind/set_node_mode/get_node_modes"),
+      name: z7.string().optional(),
+      description: z7.string().optional(),
+      modes: z7.array(z7.string()).optional().describe("create_collection: mode names"),
+      modeId: z7.string().optional(),
+      resolvedType: z7.enum(["COLOR", "FLOAT", "STRING", "BOOLEAN"]).optional(),
+      value: z7.unknown().optional().describe("Variable value (color object, number, string, bool)"),
+      property: z7.string().optional().describe('bind/unbind: node property (e.g. "fills", "width")'),
+      scopes: z7.array(z7.string()).optional(),
+      platform: z7.enum(["WEB", "ANDROID", "iOS"]).optional(),
+      hiddenFromPublishing: z7.boolean().optional(),
+      fix: z7.boolean().optional().describe("tokenize: apply the bindings (false = report only)"),
+      tolerance: z7.number().optional().describe("tokenize: OKLab \u0394E for color matches (default 0.02 \u2248 visually identical)")
+    },
+    async (args) => {
+      try {
+        const [command, fields] = ACTIONS[args.action];
+        const params = Object.fromEntries(
+          fields.map((f) => [f, args[f]]).filter(([, v]) => v !== void 0)
+        );
+        const result = await sendCommand(
+          command,
+          params,
+          args.action === "tokenize" ? 12e4 : void 0
+        );
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/styles.ts
+var styles_exports = {};
+__export(styles_exports, {
+  register: () => register7
+});
+import { z as z8 } from "zod";
+function register7(server, sendCommand) {
+  server.tool(
+    "manage_styles",
+    "Shared styles: list all local styles; create_paint / create_text / create_effect / create_grid; update (name/properties); delete; apply (style to a node); reorder. To bind variables instead of styles, use manage_variables.",
+    {
+      action: z8.enum([
+        "list",
+        "create_paint",
+        "create_text",
+        "create_effect",
+        "create_grid",
+        "update",
+        "delete",
+        "apply",
+        "reorder"
+      ]),
+      name: z8.string().optional().describe("Style name (create_*/update)"),
+      styleId: z8.string().optional().describe("Target style (update/delete/apply/reorder)"),
+      styleType: z8.enum(["PAINT", "TEXT", "EFFECT", "GRID"]).optional().describe("apply/reorder"),
+      nodeId: z8.string().optional().describe("apply: target node"),
+      color: colorSchema.optional().describe("create_paint/create_effect"),
+      gradientType: gradientTypeSchema.optional(),
+      gradientStops: z8.array(gradientStopSchema).optional(),
+      fontFamily: z8.string().optional().describe("create_text"),
+      fontSize: z8.number().positive().optional(),
+      fontWeight: z8.number().optional(),
+      lineHeight: z8.number().optional(),
+      letterSpacing: z8.number().optional(),
+      effectType: z8.enum(["DROP_SHADOW", "INNER_SHADOW", "LAYER_BLUR", "BACKGROUND_BLUR"]).optional().describe("create_effect"),
+      offsetX: z8.number().optional(),
+      offsetY: z8.number().optional(),
+      radius: z8.number().min(0).optional(),
+      spread: z8.number().optional(),
+      grids: z8.array(z8.record(z8.unknown())).optional().describe("create_grid: layout grid objects"),
+      properties: z8.record(z8.unknown()).optional().describe("update: properties to change"),
+      afterStyleId: z8.string().optional().describe("reorder: place after this style")
+    },
+    async (args) => {
+      try {
+        let result;
+        switch (args.action) {
+          case "list":
+            result = await sendCommand("get_styles", {});
+            break;
+          case "create_paint":
+            result = await sendCommand("create_paint_style", {
+              name: args.name,
+              color: args.color,
+              gradientType: args.gradientType,
+              gradientStops: args.gradientStops
+            });
+            break;
+          case "create_text":
+            result = await sendCommand("create_text_style", {
+              name: args.name,
+              fontFamily: args.fontFamily,
+              fontSize: args.fontSize,
+              fontWeight: args.fontWeight,
+              lineHeight: args.lineHeight,
+              letterSpacing: args.letterSpacing
+            });
+            break;
+          case "create_effect":
+            result = await sendCommand("create_effect_style", {
+              name: args.name,
+              effectType: args.effectType,
+              color: args.color,
+              offsetX: args.offsetX,
+              offsetY: args.offsetY,
+              radius: args.radius,
+              spread: args.spread
+            });
+            break;
+          case "create_grid":
+            result = await sendCommand("create_grid_style", { name: args.name, grids: args.grids });
+            break;
+          case "update":
+            result = await sendCommand("update_style", {
+              styleId: args.styleId,
+              name: args.name,
+              properties: args.properties
+            });
+            break;
+          case "delete":
+            result = await sendCommand("delete_style", { styleId: args.styleId });
+            break;
+          case "apply":
+            result = await sendCommand("apply_style", {
+              nodeId: args.nodeId,
+              styleId: args.styleId,
+              styleType: args.styleType
+            });
+            break;
+          case "reorder":
+            result = await sendCommand("reorder_style", {
+              styleId: args.styleId,
+              afterStyleId: args.afterStyleId,
+              styleType: args.styleType
+            });
+            break;
+        }
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/pages.ts
+var pages_exports = {};
+__export(pages_exports, {
+  register: () => register8
+});
+import { z as z9 } from "zod";
+function register8(server, sendCommand) {
+  server.tool(
+    "manage_pages",
+    "Page operations: list all pages, create/rename/delete a page, or set a page's background color. To make a page current, use navigate with switch_page.",
+    {
+      action: z9.enum(["list", "create", "rename", "delete", "set_background"]),
+      pageId: z9.string().optional().describe("Target page (rename/delete/set_background)"),
+      name: z9.string().optional().describe("Page name (create/rename)"),
+      color: colorSchema.optional().describe("Background color (set_background)")
+    },
+    async ({ action, pageId, name, color }) => {
+      try {
+        let result;
+        switch (action) {
+          case "list":
+            result = await sendCommand("get_pages", {});
+            break;
+          case "create":
+            result = await sendCommand("create_page", { name });
+            break;
+          case "rename":
+            result = await sendCommand("rename_page", { pageId, name });
+            break;
+          case "delete":
+            result = await sendCommand("delete_page", { pageId });
+            break;
+          case "set_background":
+            result = await sendCommand("set_page_background", { pageId, color });
+            break;
+        }
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/navigate.ts
+var navigate_exports = {};
+__export(navigate_exports, {
+  register: () => register9
+});
+import { z as z10 } from "zod";
+function register9(server, sendCommand) {
+  server.tool(
+    "navigate",
+    "Control the designer's view: focus (scroll+zoom to a node), select (set the selection), get_viewport / set_viewport (x/y/zoom), or switch_page.",
+    {
+      action: z10.enum(["focus", "select", "get_viewport", "set_viewport", "switch_page"]),
+      nodeId: z10.string().optional().describe("focus target"),
+      nodeIds: z10.array(z10.string()).optional().describe("select targets"),
+      x: z10.number().optional().describe("set_viewport center x"),
+      y: z10.number().optional(),
+      zoom: z10.number().positive().optional(),
+      pageId: z10.string().optional().describe("switch_page target")
+    },
+    async ({ action, nodeId, nodeIds, x, y, zoom, pageId }) => {
+      try {
+        let result;
+        switch (action) {
+          case "focus":
+            result = await sendCommand("set_focus", { nodeId });
+            break;
+          case "select":
+            result = await sendCommand("set_selections", { nodeIds });
+            break;
+          case "get_viewport":
+            result = await sendCommand("get_viewport", {});
+            break;
+          case "set_viewport":
+            result = await sendCommand("set_viewport", { x, y, zoom });
+            break;
+          case "switch_page":
+            result = await sendCommand("switch_page", { pageId });
+            break;
+        }
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/assets.ts
+var assets_exports = {};
+__export(assets_exports, {
+  register: () => register10
+});
+import { z as z11 } from "zod";
+function register10(server, sendCommand) {
+  server.tool(
+    "export_asset",
+    "Export a node as PNG/JPG/SVG/PDF. Returns base64 data for saving to disk. For a quick visual check of your work, prefer the screenshot tool (returns a viewable image).",
+    {
+      nodeId: z11.string().describe("Node to export"),
+      format: exportFormatSchema.optional().describe("Default PNG"),
+      scale: z11.number().positive().optional().describe("Export scale (default 1)")
+    },
+    { readOnlyHint: true },
+    async ({ nodeId, format, scale }) => {
+      try {
+        const result = await sendCommand("export_node_as_image", { nodeId, format, scale }, 6e4);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.tool(
+    "add_image",
+    "Place an image: from a URL (creates a new image node) or as a fill on an existing node (base64 imageData). scaleMode controls how the image fits.",
+    {
+      url: z11.string().optional().describe("Image URL \u2014 creates a new node"),
+      nodeId: z11.string().optional().describe("Existing node \u2014 sets its fill from imageData"),
+      imageData: z11.string().optional().describe("Base64 image data (with nodeId)"),
+      x: z11.number().optional(),
+      y: z11.number().optional(),
+      width: z11.number().positive().optional(),
+      height: z11.number().positive().optional(),
+      name: z11.string().optional(),
+      scaleMode: z11.enum(["FILL", "FIT", "CROP", "TILE"]).optional()
+    },
+    async ({ url, nodeId, imageData, x, y, width, height, name, scaleMode }) => {
+      try {
+        if (url) {
+          const result = await sendCommand(
+            "create_image_from_url",
+            { url, x, y, width, height, name, scaleMode },
+            6e4
+          );
+          return jsonResult(result);
+        }
+        if (nodeId && imageData) {
+          const result = await sendCommand("set_image_fill", { nodeId, imageData, scaleMode }, 6e4);
+          return jsonResult(result);
+        }
+        return textResult("Provide either url (new image node) or nodeId + imageData (image fill).");
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/library.ts
+var library_exports = {};
+__export(library_exports, {
+  register: () => register11
+});
+import { z as z12 } from "zod";
+function register11(server, sendCommand) {
+  server.tool(
+    "import_from_library",
+    "Import a component, style, or variable from an enabled team library by its key. Component keys come from the design system or get_local_components; imported components can then be instantiated with manage_components.",
+    {
+      kind: z12.enum(["component", "style", "variable"]),
+      key: z12.string().describe("Library key")
+    },
+    async ({ kind, key }) => {
+      try {
+        const command = kind === "component" ? "import_component_by_key" : kind === "style" ? "import_style_by_key" : "import_variable_by_key";
+        const result = await sendCommand(command, { key }, 6e4);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/annotate.ts
+var annotate_exports = {};
+__export(annotate_exports, {
+  register: () => register12
+});
+import { z as z13 } from "zod";
+function register12(server, sendCommand) {
+  server.tool(
+    "annotate",
+    "Read or write Dev Mode annotations. get: read annotations on a node. set: add/update one annotation (labelMarkdown). set_multiple: batch annotations.",
+    {
+      action: z13.enum(["get", "set", "set_multiple"]),
+      nodeId: z13.string().optional().describe("Target node (get/set)"),
+      labelMarkdown: z13.string().optional().describe("Annotation text (set)"),
+      categoryId: z13.string().optional(),
+      annotations: z13.array(
+        z13.object({
+          nodeId: z13.string(),
+          labelMarkdown: z13.string(),
+          categoryId: z13.string().optional()
+        })
+      ).optional().describe("Batch annotations (set_multiple)")
+    },
+    async ({ action, nodeId, labelMarkdown, categoryId, annotations }) => {
+      try {
+        if (action === "get") {
+          const result2 = await sendCommand("get_annotations", { nodeId });
+          return jsonResult(result2);
+        }
+        if (action === "set") {
+          if (!nodeId || labelMarkdown === void 0)
+            return textResult("set requires nodeId and labelMarkdown.");
+          const result2 = await sendCommand("set_annotation", { nodeId, labelMarkdown, categoryId });
+          return jsonResult(result2);
+        }
+        if (!annotations?.length) return textResult("set_multiple requires annotations.");
+        const result = await sendCommand("set_multiple_annotations", { annotations });
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/read.ts
+var read_exports = {};
+__export(read_exports, {
+  register: () => register13
+});
+import { z as z14 } from "zod";
+function register13(server, sendCommand) {
+  server.tool(
+    "get_node_data",
+    "Raw node data at a chosen detail level: summary (shallow), tree (sparse structure for orientation), full (deeper serialization), css (CSS representation), variables (bound variable ids). For human-oriented summaries prefer get_node_details / get_selection_context.",
+    {
+      nodeIds: z14.array(z14.string()).min(1).describe("One or more node ids"),
+      detail: z14.enum(["summary", "tree", "full", "css", "variables"]).optional().describe("Default summary"),
+      depth: z14.number().int().min(0).optional().describe("Override serialization depth"),
+      maxNodes: z14.number().int().positive().optional().describe("Override node budget")
+    },
+    { readOnlyHint: true },
+    async ({ nodeIds, detail = "summary", depth, maxNodes }) => {
+      try {
+        if (detail === "css" || detail === "variables") {
+          const command = detail === "css" ? "get_css" : "get_bound_variables";
+          const results = [];
+          for (const nodeId of nodeIds) {
+            results.push({ nodeId, data: await sendCommand(command, { nodeId }) });
+          }
+          return jsonResult(nodeIds.length === 1 ? results[0].data : results);
+        }
+        if (detail === "tree") {
+          const results = [];
+          for (const nodeId of nodeIds) {
+            results.push(await sendCommand("get_node_tree", { nodeId, depth, maxNodes }));
+          }
+          return jsonResult(nodeIds.length === 1 ? results[0] : results);
+        }
+        if (nodeIds.length > 1) {
+          const result2 = await sendCommand("get_nodes_info", { nodeIds });
+          return jsonResult(result2);
+        }
+        const result = await sendCommand("get_node_info", {
+          nodeId: nodeIds[0],
+          depth: depth ?? (detail === "full" ? 4 : 1),
+          maxNodes
+        });
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/execute.ts
+var execute_exports = {};
+__export(execute_exports, {
+  register: () => register14
+});
+import { z as z15 } from "zod";
+function register14(server, sendCommand) {
+  server.tool(
+    "execute_figma",
+    "Run JavaScript against the Figma Plugin API inside the plugin sandbox \u2014 the escape hatch for anything the other tools don't cover. The code runs in an async function with `figma` AND `relai` in scope. relai helpers avoid the classic pitfalls: relai.text(parent, chars, {font,size,color}) loads fonts first; relai.autoLayout(direction, props) makes a hugging auto-layout frame; relai.set(node, props) applies layoutMode first and routes width/height through resize; relai.hug(node); relai.focusRing(node); await relai.page(p => ...) finds pages by content, not name; relai.query('FRAME[name^=Card] > TEXT') is a CSS-like search (types, name matchers, descendant/child, comma); relai.placeholder(node) shows a construction veil \u2014 remove with (node, false) when done. Errors carry a Hint with the fix; scripts are NOT atomic \u2014 on error, partial changes persist, so keep scripts small and idempotent. Nodes created via relai plus any node ids you RETURN are linted for silent mistakes (e.g. spread shadows without clipsContent) and come back as `warnings`. Return ALL created/mutated node ids. Work incrementally; verify with screenshot. When BUILDING UI: call get_design_system first and instantiate the file's own components / bind its variables instead of drawing raw shapes \u2014 hand-drawn near-copies of existing components read as drift to the design team. The designer can disable this tool via the plugin's 'Allow code execution' toggle.",
+    {
+      code: z15.string().describe("JavaScript source. May use await. Return a JSON-serializable value."),
+      description: z15.string().optional().describe("One line shown in the plugin's activity feed describing what this does"),
+      timeoutMs: z15.number().int().min(1e3).max(3e5).optional().describe("Execution timeout in ms (default 60000) \u2014 raise for scripts creating hundreds of nodes")
+    },
+    async ({ code, description, timeoutMs }) => {
+      try {
+        const result = await sendCommand("execute_code", { code, description }, timeoutMs ?? 6e4);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/comments.ts
+var comments_exports = {};
+__export(comments_exports, {
+  parseFileKey: () => parseFileKey,
+  register: () => register15
+});
+import { z as z16 } from "zod";
+var API = "https://api.figma.com/v1";
+function parseFileKey(input) {
+  const url = input.match(/figma\.com\/(?:file|design)\/([A-Za-z0-9]+)/);
+  if (url) return url[1];
+  if (/^[A-Za-z0-9]{15,}$/.test(input)) return input;
+  return null;
+}
+function compactComment(c) {
+  return {
+    id: c.id,
+    message: c.message,
+    author: c.user?.handle,
+    created_at: c.created_at,
+    ...c.resolved_at ? { resolved: true } : {},
+    ...c.parent_id ? { replyTo: c.parent_id } : {},
+    ...c.client_meta?.node_id ? { nodeId: c.client_meta.node_id } : {}
+  };
+}
+function register15(server, sendCommand) {
+  server.tool(
+    "manage_comments",
+    "Read and write comments on the Figma file: list (with node anchors \u2014 great for 'apply the feedback in the comments' or polling for designer requests; filter with unresolved:true and since:<ISO date>), add (optionally pinned to a node), reply, delete. Comment-driven workflow: designers leave asks as comments in Figma; poll list (unresolved + since last check), do the work, then reply on the thread with what was done. Requires a FIGMA_TOKEN env var (personal access token with comment scopes, generated at figma.com Settings \u2192 Security); the canvas tools work without it. The file is auto-detected from the open plugin when possible \u2014 otherwise pass fileUrl.",
+    {
+      action: z16.enum(["list", "add", "reply", "delete"]),
+      fileUrl: z16.string().optional().describe("Figma file URL or key (auto-detected when omitted)"),
+      message: z16.string().optional().describe("Comment text (add/reply)"),
+      commentId: z16.string().optional().describe("Target comment (reply/delete)"),
+      nodeId: z16.string().optional().describe("add: pin the comment to this node"),
+      x: z16.number().optional().describe("add: canvas position (with y, when not pinning to a node)"),
+      y: z16.number().optional(),
+      since: z16.string().optional().describe("list: only comments created after this ISO 8601 timestamp"),
+      unresolved: z16.boolean().optional().describe("list: only unresolved threads")
+    },
+    async ({ action, fileUrl, message, commentId, nodeId, x, y, since, unresolved }) => {
+      const token = process.env.FIGMA_TOKEN;
+      if (!token) {
+        return textResult(
+          'Comments need a Figma personal access token. Generate one at figma.com \u2192 Settings \u2192 Security \u2192 Personal access tokens (enable comment scopes), then add it to the MCP config: "env": { "FIGMA_TOKEN": "figd_..." } and restart. Everything else works without it.'
+        );
+      }
+      try {
+        let fileKey = fileUrl ? parseFileKey(fileUrl) : null;
+        if (fileUrl && !fileKey) {
+          return textResult(`Could not extract a file key from "${fileUrl}" \u2014 pass a figma.com/design/... URL.`);
+        }
+        if (!fileKey) {
+          const info = await sendCommand("get_file_info", {});
+          fileKey = info?.fileKey ?? null;
+        }
+        if (!fileKey) {
+          return textResult(
+            "Figma doesn't expose this file's key to the plugin. Pass fileUrl with the file's figma.com URL (copy it from the browser or Share dialog)."
+          );
+        }
+        const request = async (method, path, body) => {
+          const res = await fetch(`${API}${path}`, {
+            method,
+            headers: {
+              "X-Figma-Token": token,
+              ...body ? { "Content-Type": "application/json" } : {}
+            },
+            ...body ? { body: JSON.stringify(body) } : {}
+          });
+          const json = await res.json().catch(() => ({}));
+          if (!res.ok) {
+            throw new Error(
+              `Figma API ${res.status}: ${json.err ?? json.message ?? "request failed"}` + (res.status === 403 ? " \u2014 check the token's comment scopes and file access" : "")
+            );
+          }
+          return json;
+        };
+        switch (action) {
+          case "list": {
+            const data = await request("GET", `/files/${fileKey}/comments`);
+            let raw = data.comments ?? [];
+            if (unresolved) raw = raw.filter((c) => !c.resolved_at);
+            if (since) {
+              const cutoff = Date.parse(since);
+              if (Number.isNaN(cutoff)) {
+                return textResult(`since "${since}" is not a parseable ISO 8601 timestamp.`);
+              }
+              raw = raw.filter((c) => c.created_at && Date.parse(c.created_at) > cutoff);
+            }
+            const comments = raw.slice(0, 100).map(compactComment);
+            return jsonResult({ count: comments.length, comments, checkedAt: (/* @__PURE__ */ new Date()).toISOString() });
+          }
+          case "add": {
+            if (!message) return textResult("add requires message.");
+            const client_meta = nodeId ? { node_id: nodeId, node_offset: { x: x ?? 0, y: y ?? 0 } } : x !== void 0 && y !== void 0 ? { x, y } : void 0;
+            const data = await request("POST", `/files/${fileKey}/comments`, {
+              message,
+              ...client_meta ? { client_meta } : {}
+            });
+            return jsonResult(compactComment(data));
+          }
+          case "reply": {
+            if (!message || !commentId) return textResult("reply requires commentId and message.");
+            const data = await request("POST", `/files/${fileKey}/comments`, {
+              message,
+              comment_id: commentId
+            });
+            return jsonResult(compactComment(data));
+          }
+          case "delete": {
+            if (!commentId) return textResult("delete requires commentId.");
+            await request("DELETE", `/files/${fileKey}/comments/${commentId}`);
+            return textResult(`Comment ${commentId} deleted.`);
+          }
+        }
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+
+// src/tools/core/design-system.ts
+var design_system_exports = {};
+__export(design_system_exports, {
+  register: () => register16
+});
+import { z as z17 } from "zod";
+function register16(server, sendCommand) {
+  server.tool(
+    "get_design_system",
+    "Inventory the design system available to this file \u2014 call this BEFORE building UI, then prefer instantiating existing components (manage_components action:instantiate takes local and library keys) and binding existing variables over drawing raw shapes. Reports: local components/styles/variable collections with usage counts, remote components/styles the file already uses, and enabled libraries' variable collections. To list a library's full component catalog, pass libraryFileUrl (requires FIGMA_TOKEN). Results are cached per session \u2014 pass refresh:true after big library changes.",
+    {
+      refresh: z17.boolean().optional().describe("Rescan instead of using the session cache"),
+      libraryFileUrl: z17.string().optional().describe(
+        "figma.com URL or key of a LIBRARY file to catalog via REST (needs FIGMA_TOKEN)"
+      )
+    },
+    { readOnlyHint: true },
+    async ({ refresh, libraryFileUrl }) => {
+      try {
+        const data = await sendCommand(
+          "get_design_system",
+          { refresh: refresh ?? false },
+          12e4
+        );
+        if (libraryFileUrl) {
+          data.libraryCatalog = await fetchLibraryCatalog(libraryFileUrl);
+        }
+        return jsonResult(data);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+  server.tool(
+    "manage_conventions",
+    "File-level design conventions \u2014 a CLAUDE.md that lives INSIDE this Figma file (shared plugin data, travels with the file). action:get reads it, action:set overwrites it with markdown. get_document_overview auto-includes it, and whatever it says (naming rules, spacing habits, do-not-touch areas, library preferences) should be FOLLOWED like user instructions. When the designer states a durable preference ('always use our green', 'never touch the Archive page'), offer to record it here so every future session \u2014 from any AI client \u2014 inherits it.",
+    {
+      action: z17.enum(["get", "set"]),
+      content: z17.string().optional().describe("set: the full markdown doc (overwrites; max 20k chars)")
+    },
+    async ({ action, content }) => {
+      try {
+        if (action === "set") {
+          return jsonResult(await sendCommand("set_conventions", { content: content ?? "" }));
+        }
+        return jsonResult(await sendCommand("get_conventions", {}));
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}
+async function fetchLibraryCatalog(libraryFileUrl) {
+  const token = process.env.FIGMA_TOKEN;
+  if (!token) {
+    return {
+      note: "Full library catalogs need a FIGMA_TOKEN env var (personal access token, file read scope). Without it, components the file already uses are still listed above \u2014 or keep a 'DS palette' page with one instance of each key component so they show up there."
+    };
+  }
+  const fileKey = parseFileKey(libraryFileUrl);
+  if (!fileKey) {
+    return { note: `Could not extract a file key from "${libraryFileUrl}".` };
+  }
+  const get = async (path) => {
+    const res = await fetch(`https://api.figma.com/v1${path}`, {
+      headers: { "X-Figma-Token": token }
+    });
+    const json = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        `Figma API ${res.status} for ${path}: ${json.err ?? "request failed"}`
+      );
+    }
+    return json;
+  };
+  const [components, styles] = await Promise.all([
+    get(`/files/${fileKey}/components`),
+    get(`/files/${fileKey}/styles`)
+  ]);
+  const meta = (r) => r.meta ?? {};
+  return {
+    components: (meta(components).components ?? []).map(
+      (c) => ({ key: c.key, name: c.name, description: c.description || void 0 })
+    ),
+    styles: (meta(styles).styles ?? []).map((s) => ({
+      key: s.key,
+      name: s.name,
+      type: s.style_type
+    }))
+  };
+}
+
+// src/tools/batch.ts
+var batch_exports = {};
+__export(batch_exports, {
+  register: () => register17
+});
+import { z as z18 } from "zod";
+function textResult2(text) {
+  return { content: [{ type: "text", text }] };
+}
+function register17(server, sendCommand) {
+  server.tool(
+    "batch_execute",
+    "Execute multiple commands in a single round-trip. Use when performing 3+ similar operations (e.g., styling multiple nodes, creating many elements). Commands run sequentially. Pass dryRun:true to preview the exact command list without touching the canvas \u2014 useful for showing the designer a plan before a large batch.",
+    {
+      commands: z18.array(
+        z18.object({
+          command: z18.string().describe("Command name"),
+          params: z18.record(z18.string(), z18.unknown()).optional().describe("Command parameters")
+        })
+      ).describe("Array of commands to execute sequentially"),
+      dryRun: z18.boolean().optional().describe("Preview only \u2014 return the plan, execute nothing")
+    },
+    async ({ commands, dryRun }) => {
+      try {
+        if (dryRun) {
+          return textResult2(
+            JSON.stringify({
+              dryRun: true,
+              commandCount: commands.length,
+              commands,
+              note: "Nothing was executed. Re-run without dryRun to apply."
+            })
+          );
+        }
+        const result = await sendCommand(
+          "batch_execute",
+          { commands },
+          commands.length * 3e4
+          // Scale timeout by command count
+        );
+        return textResult2(JSON.stringify(result));
+      } catch (error) {
+        return textResult2(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  );
+}
+
+// src/tools/v2/context.ts
+var context_exports = {};
+__export(context_exports, {
+  register: () => register18,
+  styleCountsFrom: () => styleCountsFrom
+});
+import { z as z19 } from "zod";
+
+// src/semantic/response.ts
+function standardResult(opts) {
+  const response = {
+    summary: opts.summary,
+    data: opts.data
+  };
+  if (opts.warnings?.length) response.warnings = opts.warnings;
+  if (opts.recommended_next?.length) response.recommended_next = opts.recommended_next;
+  if (opts.partial_failures?.length) response.partial_failures = opts.partial_failures;
+  return {
+    content: [{ type: "text", text: JSON.stringify(response) }]
+  };
+}
+
+// src/semantic/errors.ts
+function errorResult2(category, message, recovery, extra) {
+  const error = {
+    category,
+    message,
+    recovery
+  };
+  if (extra?.preconditions) error.preconditions = extra.preconditions;
+  if (extra?.partial_result !== void 0) error.partial_result = extra.partial_result;
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error }, null, 2) }]
+  };
+}
+function noSelectionError() {
+  return errorResult2(
+    "precondition_failed",
+    "No nodes selected in Figma",
+    {
+      suggestion: "Select nodes in Figma, or use search_nodes to find nodes by name/type",
+      tool: "search_nodes"
+    },
+    { preconditions: { required: "At least 1 node selected", current_state: "Selection is empty" } }
+  );
+}
+
+// src/semantic/normalize.ts
+function normalizeNode(raw) {
+  if (!raw) return null;
+  const summary = {
+    id: raw.id,
+    name: raw.name,
+    type: raw.type,
+    size: {
+      width: raw.width ?? raw.absoluteBoundingBox?.width ?? 0,
+      height: raw.height ?? raw.absoluteBoundingBox?.height ?? 0
+    },
+    position: {
+      x: raw.x ?? raw.absoluteBoundingBox?.x ?? 0,
+      y: raw.y ?? raw.absoluteBoundingBox?.y ?? 0
+    }
+  };
+  const fill = extractFillColor(raw);
+  if (fill) summary.fill = fill;
+  const stroke = extractStrokeColor(raw);
+  if (stroke) summary.stroke = stroke;
+  if (raw.cornerRadius !== void 0) {
+    summary.cornerRadius = raw.cornerRadius === "mixed" ? "mixed" : raw.cornerRadius;
+  }
+  if (raw.opacity !== void 0 && raw.opacity < 1) {
+    summary.opacity = raw.opacity;
+  }
+  summary.layout = extractLayout(raw);
+  if (raw.children?.length > 0) {
+    summary.childSummary = summarizeChildren(raw.children);
+  }
+  summary.componentStatus = extractComponentStatus(raw);
+  return summary;
+}
+function normalizeNodes(rawNodes) {
+  return rawNodes.map(normalizeNode).filter((n) => n !== null);
+}
+function extractFillColor(node) {
+  if (!node.fills?.length) return void 0;
+  const solidFill = node.fills.find((f) => f.type === "SOLID" && f.visible !== false);
+  if (!solidFill?.color) return void 0;
+  if (typeof solidFill.color === "string" && solidFill.color.startsWith("#")) {
+    return solidFill.color;
+  }
+  return rgbaToHex({
+    r: solidFill.color.r,
+    g: solidFill.color.g,
+    b: solidFill.color.b,
+    a: solidFill.opacity ?? solidFill.color.a ?? 1
+  });
+}
+function extractStrokeColor(node) {
+  if (!node.strokes?.length) return void 0;
+  const stroke = node.strokes.find((s) => s.type === "SOLID" && s.visible !== false);
+  if (!stroke?.color) return void 0;
+  if (typeof stroke.color === "string" && stroke.color.startsWith("#")) {
+    return stroke.color;
+  }
+  return rgbaToHex({
+    r: stroke.color.r,
+    g: stroke.color.g,
+    b: stroke.color.b,
+    a: stroke.opacity ?? stroke.color.a ?? 1
+  });
+}
+function extractLayout(node) {
+  if (!node.layoutMode || node.layoutMode === "NONE") return null;
+  const pt = node.paddingTop ?? 0;
+  const pr = node.paddingRight ?? 0;
+  const pb = node.paddingBottom ?? 0;
+  const pl = node.paddingLeft ?? 0;
+  let padding;
+  if (pt === pr && pr === pb && pb === pl) {
+    padding = `${pt}px all`;
+  } else if (pt === pb && pl === pr) {
+    padding = `${pt}/${pl}`;
+  } else {
+    padding = `${pt}/${pr}/${pb}/${pl}`;
+  }
+  return {
+    mode: node.layoutMode,
+    padding,
+    gap: node.itemSpacing ?? 0,
+    sizing: {
+      horizontal: node.primaryAxisSizingMode ?? node.layoutSizingHorizontal ?? "FIXED",
+      vertical: node.counterAxisSizingMode ?? node.layoutSizingVertical ?? "FIXED"
+    }
+  };
+}
+function summarizeChildren(children) {
+  const typeCounts = /* @__PURE__ */ new Map();
+  for (const child of children) {
+    const type = child.type || "UNKNOWN";
+    typeCounts.set(type, (typeCounts.get(type) || 0) + 1);
+  }
+  const parts = Array.from(typeCounts.entries()).map(([type, count]) => `${count} ${type}`).join(", ");
+  return `${children.length} children: ${parts}`;
+}
+function extractComponentStatus(node) {
+  if (node.type === "COMPONENT") return "component";
+  if (node.type === "COMPONENT_SET") return "component_set";
+  if (node.type === "INSTANCE") {
+    const mainName = node.mainComponent?.name || node.componentName;
+    return mainName ? `instance of '${mainName}'` : "instance";
+  }
+  return null;
+}
+function calculateTokenCoverage(node, boundVariables) {
+  let totalProps = 0;
+  let boundProps = 0;
+  if (node.fills?.length > 0) {
+    totalProps++;
+    if (boundVariables && hasBinding(boundVariables, "fills")) boundProps++;
+  }
+  if (node.strokes?.length > 0) {
+    totalProps++;
+    if (boundVariables && hasBinding(boundVariables, "strokes")) boundProps++;
+  }
+  for (const prop of ["itemSpacing", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft"]) {
+    if (node[prop] !== void 0 && node[prop] > 0) {
+      totalProps++;
+      if (boundVariables && hasBinding(boundVariables, prop)) boundProps++;
+    }
+  }
+  if (node.cornerRadius !== void 0 && node.cornerRadius > 0) {
+    totalProps++;
+    if (boundVariables && hasBinding(boundVariables, "cornerRadius")) boundProps++;
+  }
+  if (totalProps === 0) return 1;
+  return Math.round(boundProps / totalProps * 100) / 100;
+}
+function hasBinding(boundVars, prefix) {
+  return Object.keys(boundVars).some((key) => key.startsWith(prefix) || key === prefix);
+}
+
+// src/tools/v2/context.ts
+function styleCountsFrom(styles) {
+  const counts = { paint: 0, text: 0, effect: 0, grid: 0 };
+  if (Array.isArray(styles)) {
+    for (const s of styles) {
+      const t = (s.type || "").toLowerCase();
+      if (t in counts) counts[t]++;
+    }
+  } else if (styles && typeof styles === "object") {
+    const o = styles;
+    counts.paint = Array.isArray(o.paintStyles) ? o.paintStyles.length : 0;
+    counts.text = Array.isArray(o.textStyles) ? o.textStyles.length : 0;
+    counts.effect = Array.isArray(o.effectStyles) ? o.effectStyles.length : 0;
+    counts.grid = Array.isArray(o.gridStyles) ? o.gridStyles.length : 0;
+  }
+  return { ...counts, total: counts.paint + counts.text + counts.effect + counts.grid };
+}
+function register18(server, sendCommand) {
+  server.tool(
+    "get_document_overview",
+    "Get the full document structure: pages, component/style/variable counts. Always call this first to understand the file. Follow with get_selection_context or search_nodes.",
+    {},
+    { readOnlyHint: true },
+    async () => {
+      try {
+        const [docInfo, collections, styles, conventions] = await Promise.all([
+          sendCommand("get_document_info"),
+          sendCommand("get_variable_collections"),
+          sendCommand("get_styles"),
+          // Older plugin builds don't have the handler — degrade quietly
+          sendCommand("get_conventions", {}).catch(() => null)
+        ]);
+        const componentCount = docInfo.componentCount ?? null;
+        const stylesByType = styleCountsFrom(styles);
+        const data = {
+          name: docInfo.name,
+          currentPage: docInfo.currentPage,
+          pages: docInfo.pages || [],
+          counts: {
+            components: componentCount,
+            styles: stylesByType.total,
+            variableCollections: Array.isArray(collections) ? collections.length : 0
+          }
+        };
+        const conventionsText = conventions?.content ?? null;
+        return standardResult({
+          summary: `"${data.name}" \u2014 ${data.pages.length} pages, ` + (data.counts.components != null ? `${data.counts.components} components, ` : "") + `${data.counts.styles} styles, ${data.counts.variableCollections} variable collections` + (data.counts.components == null ? " (component inventory via get_design_system)" : "") + (conventionsText ? ". This file has conventions \u2014 follow them (see data.conventions)." : ""),
+          data: { ...data, ...conventionsText ? { conventions: conventionsText } : {} },
+          recommended_next: [
+            { tool: "get_selection_context", reason: "Inspect currently selected nodes" },
+            { tool: "search_nodes", reason: "Find specific nodes by name or type" },
+            { tool: "get_design_tokens", reason: "Explore the design token system" }
+          ]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Failed to get document info: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected. Call join_room first.", tool: "join_room" }
+        );
+      }
+    }
+  );
+  server.tool(
+    "get_selection_context",
+    "Get full context for the current Figma selection: node properties, fills, layout, token bindings, and children summary. Use as the starting point for any inspection or modification workflow. Follow with analyze_* tools or update_node.",
+    {},
+    { readOnlyHint: true },
+    async () => {
+      try {
+        const selection = await sendCommand("get_selection");
+        if (!selection?.nodes?.length) {
+          return noSelectionError();
+        }
+        const nodeIds = selection.nodes.map((n) => n.id);
+        const [nodesInfo, ...bindings] = await Promise.all([
+          sendCommand("get_nodes_info", { nodeIds, depth: 2 }),
+          ...nodeIds.map(
+            (id) => sendCommand("get_bound_variables", { nodeId: id }).catch(() => null)
+          )
+        ]);
+        const nodes = (Array.isArray(nodesInfo) ? nodesInfo : []).map((raw, i) => {
+          const summary = normalizeNode(raw);
+          if (!summary) return null;
+          const boundVars = bindings[i]?.boundVariables || null;
+          summary.tokenCoverage = calculateTokenCoverage(raw, boundVars);
+          if (boundVars) {
+            summary.fillToken = extractTokenName(boundVars, "fills");
+            summary.strokeToken = extractTokenName(boundVars, "strokes");
+          }
+          return summary;
+        }).filter(Boolean);
+        const data = {
+          nodes,
+          pageInfo: selection.currentPage || { id: "", name: "" }
+        };
+        const avgCoverage = nodes.length > 0 ? Math.round(nodes.reduce((sum, n) => sum + (n.tokenCoverage || 0), 0) / nodes.length * 100) : 0;
+        const warnings = [];
+        if (avgCoverage < 50) {
+          warnings.push({
+            category: "tokens",
+            message: `Token coverage is ${avgCoverage}% \u2014 many properties are not bound to design variables`
+          });
+        }
+        return standardResult({
+          summary: `Selected ${nodes.length} node(s): ${nodes.map((n) => `'${n.name}' (${n.type})`).join(", ")}. Token coverage: ${avgCoverage}%`,
+          data,
+          warnings,
+          recommended_next: [
+            { tool: "analyze_color_usage", reason: "Audit color consistency and token coverage" },
+            { tool: "update_node", reason: "Modify selected node properties" },
+            { tool: "screenshot", reason: "Visually inspect the selection" }
+          ]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Failed to get selection: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+  server.tool(
+    "get_node_details",
+    "Get a single node's full properties, CSS, token bindings, and children. Use after search_nodes or get_selection_context to inspect a specific node. Follow with update_node or analyze_* tools.",
+    {
+      nodeId: z19.string().describe("The node ID to inspect")
+    },
+    { readOnlyHint: true },
+    async ({ nodeId }) => {
+      try {
+        const [nodeInfo, boundVars, css] = await Promise.all([
+          sendCommand("get_node_info", { nodeId, depth: 2 }),
+          sendCommand("get_bound_variables", { nodeId }).catch(() => null),
+          sendCommand("get_css", { nodeId }).catch(() => null)
+        ]);
+        if (!nodeInfo) {
+          return errorResult2(
+            "invalid_input",
+            `Node '${nodeId}' not found`,
+            { suggestion: "Use search_nodes to find the correct node ID", tool: "search_nodes" }
+          );
+        }
+        const node = normalizeNode(nodeInfo);
+        if (!node) {
+          return errorResult2(
+            "invalid_input",
+            `Could not process node '${nodeId}'`,
+            { suggestion: "Try get_node_info directly for raw data", tool: "get_node_info" }
+          );
+        }
+        const bv = boundVars?.boundVariables || null;
+        node.tokenCoverage = calculateTokenCoverage(nodeInfo, bv);
+        if (bv) {
+          node.fillToken = extractTokenName(bv, "fills");
+          node.strokeToken = extractTokenName(bv, "strokes");
+        }
+        const children = nodeInfo.children ? normalizeNodes(nodeInfo.children) : void 0;
+        const data = {
+          node,
+          css: css?.css,
+          boundVariables: bv || void 0,
+          children
+        };
+        return standardResult({
+          summary: `'${node.name}' (${node.type}, ${node.size.width}\xD7${node.size.height}). Token coverage: ${Math.round((node.tokenCoverage || 0) * 100)}%`,
+          data,
+          recommended_next: [
+            { tool: "update_node", reason: "Modify this node's properties", args: { nodeId } },
+            { tool: "analyze_color_usage", reason: "Check color token usage", args: { nodeId } }
+          ]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Failed to get node details: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+  server.tool(
+    "search_nodes",
+    "Search for nodes by name and/or type within a scope. Returns matching node IDs, names, and types. Use to find specific elements before inspecting or modifying them. Follow with get_node_details or update_node.",
+    {
+      query: z19.string().optional().describe("Name substring to search for"),
+      types: z19.array(z19.string()).optional().describe("Node types to filter: FRAME, TEXT, COMPONENT, INSTANCE, RECTANGLE, etc."),
+      parentId: z19.string().optional().describe("Scope search to children of this node (default: current page)")
+    },
+    { readOnlyHint: true },
+    async ({ query, types, parentId }) => {
+      try {
+        const result = await sendCommand("find_nodes", {
+          name: query,
+          types,
+          parentId
+        });
+        const matches = (Array.isArray(result) ? result : []).map((n) => ({
+          id: n.id,
+          name: n.name,
+          type: n.type,
+          parentName: n.parent?.name
+        }));
+        const data = {
+          matches,
+          total: matches.length
+        };
+        return standardResult({
+          summary: `Found ${matches.length} node(s)${query ? ` matching '${query}'` : ""}${types?.length ? ` of type ${types.join("/")}` : ""}`,
+          data,
+          recommended_next: matches.length > 0 ? [
+            { tool: "get_node_details", reason: "Inspect a specific node", args: { nodeId: matches[0].id } },
+            { tool: "navigate_to", reason: "Focus on a found node", args: { nodeId: matches[0].id } }
+          ] : [
+            { tool: "get_document_overview", reason: "Check document structure" }
+          ]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Search failed: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+  server.tool(
+    "get_design_tokens",
+    "Get an overview of the design token system: variable collections, modes, variable counts, and style counts. Use to understand the design system before binding tokens or creating new variables. Follow with manage_variables or bind_tokens.",
+    {},
+    { readOnlyHint: true },
+    async () => {
+      try {
+        const [collections, styles] = await Promise.all([
+          sendCommand("get_variable_collections"),
+          sendCommand("get_styles")
+        ]);
+        const collectionSummaries = (Array.isArray(collections) ? collections : []).map((c) => ({
+          id: c.id,
+          name: c.name,
+          modes: Array.isArray(c.modes) ? c.modes : [],
+          variableCount: Array.isArray(c.variableIds) ? c.variableIds.length : 0
+        }));
+        const { total: _ignored, ...stylesByType } = styleCountsFrom(styles);
+        const totalVars = collectionSummaries.reduce((sum, c) => sum + c.variableCount, 0);
+        const data = {
+          collections: collectionSummaries,
+          styles: stylesByType
+        };
+        return standardResult({
+          summary: `${collectionSummaries.length} collection(s) with ${totalVars} variables. Styles: ${stylesByType.paint} paint, ${stylesByType.text} text, ${stylesByType.effect} effect, ${stylesByType.grid} grid`,
+          data,
+          recommended_next: [
+            { tool: "manage_variables", reason: "Create or update design tokens" },
+            { tool: "analyze_color_usage", reason: "Check token coverage on selected nodes" }
+          ]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Failed to get design tokens: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+  server.tool(
+    "screenshot",
+    "Take a PNG screenshot of a node or the current view. Returns an image visible to the AI. Use to visually verify changes or inspect design details. Works for both context inspection and verification after modifications.",
+    {
+      nodeId: z19.string().optional().describe("Node ID to screenshot (default: current view)")
+    },
+    { readOnlyHint: true },
+    async ({ nodeId }) => {
+      try {
+        const result = await sendCommand("get_screenshot", nodeId ? { nodeId } : {});
+        if (result?.imageData) {
+          return {
+            content: [
+              {
+                type: "image",
+                data: result.imageData,
+                mimeType: "image/png"
+              },
+              {
+                type: "text",
+                text: JSON.stringify({
+                  summary: `Screenshot taken${nodeId ? ` of node ${nodeId}` : " of current view"}`,
+                  recommended_next: [
+                    { tool: "get_selection_context", reason: "Get structured data about the selection" },
+                    { tool: "update_node", reason: "Make changes based on what you see" }
+                  ]
+                })
+              }
+            ]
+          };
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }]
+        };
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Screenshot failed: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+}
+function extractTokenName(boundVars, prefix) {
+  for (const [key, value] of Object.entries(boundVars)) {
+    if (key.startsWith(prefix) || key === prefix) {
+      if (value && typeof value === "object" && "name" in value) {
+        return value.name;
+      }
+      if (typeof value === "string") return value;
+    }
+  }
+  return null;
+}
+
+// src/tools/v2/analysis.ts
+var analysis_exports = {};
+__export(analysis_exports, {
+  collectColorIssues: () => collectColorIssues,
+  register: () => register19
+});
+import { z as z20 } from "zod";
+
+// src/semantic/health.ts
+var WEIGHTS = { color: 0.3, layout: 0.25, components: 0.2, accessibility: 0.25 };
+var clamp = (n) => Math.max(0, Math.min(100, Math.round(n)));
+function computeHealthScore(inputs) {
+  const categories = [];
+  if (inputs.color) {
+    categories.push({
+      category: "color",
+      score: clamp(inputs.color.tokenCoverage * 100),
+      weight: WEIGHTS.color,
+      note: `${Math.round(inputs.color.tokenCoverage * 100)}% of color properties bound to tokens (${inputs.color.unboundCount} unbound)`
+    });
+  }
+  if (inputs.layout) {
+    categories.push({
+      category: "layout",
+      score: clamp(inputs.layout.autoLayoutCoverage * 100 - inputs.layout.issueCount * 3),
+      weight: WEIGHTS.layout,
+      note: `${Math.round(inputs.layout.autoLayoutCoverage * 100)}% auto-layout coverage, ${inputs.layout.issueCount} issue(s)`
+    });
+  }
+  if (inputs.components) {
+    const { totalInstances, detachedCount } = inputs.components;
+    categories.push({
+      category: "components",
+      score: totalInstances > 0 ? clamp((1 - detachedCount / totalInstances) * 100) : 100,
+      weight: WEIGHTS.components,
+      note: totalInstances > 0 ? `${detachedCount}/${totalInstances} instances look detached` : "no instances in scope"
+    });
+  }
+  if (inputs.accessibility) {
+    categories.push({
+      category: "accessibility",
+      score: clamp(100 - inputs.accessibility.issueCount * 8),
+      weight: WEIGHTS.accessibility,
+      note: `${inputs.accessibility.issueCount} issue(s) found`
+    });
+  }
+  const totalWeight = categories.reduce((s, c) => s + c.weight, 0);
+  const score = totalWeight > 0 ? clamp(categories.reduce((s, c) => s + c.score * c.weight, 0) / totalWeight) : 0;
+  const grade = score >= 90 ? "A" : score >= 75 ? "B" : score >= 55 ? "C" : "D";
+  return { score, grade, categories };
+}
+
+// src/tools/v2/analysis.ts
+var ASPECT_TOOL = {
+  color: "analyze_color_usage",
+  layout: "analyze_layout_quality",
+  components: "analyze_component_health",
+  accessibility: "analyze_accessibility"
+};
+function register19(server, sendCommand) {
+  const aspectHandlers = /* @__PURE__ */ new Map();
+  const interceptor = new Proxy(server, {
+    get(target, prop, receiver) {
+      if (prop !== "tool") return Reflect.get(target, prop, receiver);
+      return (name, ...rest) => {
+        if (name.startsWith("analyze_")) {
+          aspectHandlers.set(name, rest[rest.length - 1]);
+          return;
+        }
+        return target.tool.call(target, name, ...rest);
+      };
+    }
+  });
+  registerAnalysisTools(interceptor, sendCommand);
+  server.tool(
+    "analyze_design",
+    "Audit the design from one aspect: color (token coverage, unbound fills/strokes), layout (auto-layout quality, spacing consistency), components (detached instances, component health), accessibility (WCAG contrast incl. large-text thresholds, touch targets, minimum text sizes), tokens (hardcoded values that match an existing variable \u2014 each finding names the variable to bind; fix in one shot with manage_variables action:tokenize fix:true), or overall (runs color/layout/components/accessibility and returns a weighted 0-100 health score \u2014 good for audits and reports). Defaults to the current selection; tokens defaults to the current page.",
+    {
+      aspect: z20.enum(["color", "layout", "components", "accessibility", "tokens", "overall"]),
+      nodeId: z20.string().optional().describe("Root node to analyze (default: current selection)")
+    },
+    { readOnlyHint: true },
+    async ({ aspect, nodeId }) => {
+      if (aspect === "overall") {
+        return runOverallAudit(aspectHandlers, nodeId);
+      }
+      if (aspect === "tokens") {
+        return runTokenDrift(sendCommand, nodeId);
+      }
+      const handler = aspectHandlers.get(ASPECT_TOOL[aspect]);
+      if (!handler) throw new Error(`Unknown aspect: ${aspect}`);
+      return handler({ nodeId });
+    }
+  );
+}
+async function runTokenDrift(sendCommand, nodeId) {
+  const data = await sendCommand("scan_token_drift", { nodeId, fix: false }, 12e4);
+  const matched = data.stats?.matched ?? 0;
+  return standardResult({
+    summary: data.note ?? (matched === 0 ? `No token drift: nothing hardcoded matches an existing variable (${data.stats?.nodesScanned ?? 0} nodes scanned).` : `${matched} hardcoded value(s) match an existing variable and could be bound.`),
+    data,
+    warnings: matched > 0 ? [
+      {
+        category: "general",
+        message: `${matched} value(s) drift from tokens they visually match`
+      }
+    ] : [],
+    recommended_next: matched > 0 ? [
+      {
+        tool: "manage_variables",
+        reason: 'Bind them in one pass: action "tokenize" with fix: true'
+      }
+    ] : []
+  });
+}
+async function runOverallAudit(aspectHandlers, nodeId) {
+  const parse = (result) => {
+    try {
+      const text = result.content?.[0]?.text ?? "";
+      const parsed = JSON.parse(text);
+      return parsed?.data ?? null;
+    } catch {
+      return null;
+    }
+  };
+  const run = async (tool) => {
+    const handler = aspectHandlers.get(tool);
+    if (!handler) return null;
+    try {
+      return parse(await handler({ nodeId }));
+    } catch {
+      return null;
+    }
+  };
+  const [color, layout, components, accessibility] = await Promise.all([
+    run("analyze_color_usage"),
+    run("analyze_layout_quality"),
+    run("analyze_component_health"),
+    run("analyze_accessibility")
+  ]);
+  const inputs = {
+    color: color ? { tokenCoverage: color.tokenCoverage ?? 0, unboundCount: color.unboundCount ?? 0 } : null,
+    layout: layout ? {
+      autoLayoutCoverage: layout.autoLayoutCoverage ?? 0,
+      issueCount: layout.issues?.length ?? 0
+    } : null,
+    components: components ? {
+      totalInstances: components.totalInstances ?? 0,
+      detachedCount: components.detachedCount ?? 0
+    } : null,
+    accessibility: accessibility ? { issueCount: accessibility.issueCount ?? 0 } : null
+  };
+  const health = computeHealthScore(inputs);
+  const excluded = Object.keys(inputs).filter((k) => !inputs[k]);
+  const worst = [...health.categories].sort((a, b) => a.score - b.score)[0];
+  return standardResult({
+    summary: `Design health: ${health.score}/100 (grade ${health.grade}). Weakest area: ${worst ? `${worst.category} at ${worst.score}` : "n/a"}.`,
+    data: {
+      ...health,
+      ...excluded.length > 0 ? { excluded } : {},
+      details: { color, layout, components, accessibility }
+    },
+    warnings: health.grade === "A" ? [] : health.categories.filter((c) => c.score < 75).map((c) => ({
+      category: "general",
+      message: `${c.category}: ${c.score}/100 \u2014 ${c.note}`
+    })),
+    recommended_next: worst ? [
+      {
+        tool: "analyze_design",
+        reason: `Drill into the weakest area with aspect: "${worst.category}"`
+      }
+    ] : []
+  });
+}
+function registerAnalysisTools(server, sendCommand) {
+  server.tool(
+    "analyze_color_usage",
+    "Audit color consistency and design token coverage for a node tree. Reports which fill/stroke colors are not bound to variables. Use after get_selection_context to diagnose token gaps. Follow with bind_tokens to fix issues.",
+    {
+      nodeId: z20.string().optional().describe("Root node to analyze (default: current selection)")
+    },
+    { readOnlyHint: true },
+    async ({ nodeId }) => {
+      try {
+        let targetIds;
+        if (nodeId) {
+          targetIds = [nodeId];
+        } else {
+          const selection = await sendCommand("get_selection");
+          if (!selection?.nodes?.length) return noSelectionError();
+          targetIds = selection.nodes.map((n) => n.id);
+        }
+        const unboundColors = [];
+        const counters = { totalProps: 0, boundCount: 0 };
+        let hiddenCount = 0;
+        let scanned = 0;
+        let capped = false;
+        for (const id of targetIds) {
+          let audit = null;
+          try {
+            audit = await sendCommand("audit_colors", { nodeId: id }, 6e4);
+          } catch {
+            audit = null;
+          }
+          if (audit && typeof audit.totalProperties === "number") {
+            counters.totalProps += audit.totalProperties;
+            counters.boundCount += audit.boundCount ?? 0;
+            hiddenCount += audit.hiddenCount ?? 0;
+            scanned += audit.scanned ?? 0;
+            capped = capped || !!audit.capped;
+            for (const issue of audit.issues ?? []) unboundColors.push(issue);
+            continue;
+          }
+          const [nodeInfo, boundVars] = await Promise.all([
+            sendCommand("get_node_info", { nodeId: id, depth: 2, maxNodes: 200 }),
+            sendCommand("get_bound_variables", { nodeId: id }).catch(() => null)
+          ]);
+          if (!nodeInfo) continue;
+          const bv = boundVars?.boundVariables || {};
+          collectColorIssues(nodeInfo, bv, unboundColors, counters);
+          if (nodeInfo.children) {
+            for (const child of nodeInfo.children) {
+              const childBv = await sendCommand("get_bound_variables", { nodeId: child.id }).catch(() => null);
+              const cbv = childBv?.boundVariables || {};
+              collectColorIssues(child, cbv, unboundColors, counters);
+            }
+          }
+        }
+        const tokenCoverage = counters.totalProps > 0 ? Math.round(counters.boundCount / counters.totalProps * 100) / 100 : 1;
+        const data = {
+          totalProperties: counters.totalProps,
+          boundCount: counters.boundCount,
+          unboundCount: unboundColors.length,
+          tokenCoverage,
+          unboundColors,
+          ...hiddenCount ? { hiddenCount } : {},
+          ...scanned ? { scanned } : {},
+          ...capped ? { capped } : {}
+        };
+        const visibleIssues = unboundColors.length - hiddenCount;
+        const warnings = unboundColors.length > 0 ? [{ category: "tokens", message: `${unboundColors.length} color(s) not bound to design tokens${hiddenCount ? ` (${hiddenCount} on hidden paints)` : ""}` }] : [];
+        return standardResult({
+          summary: `Color audit: ${visibleIssues} unbound color(s)` + (hiddenCount ? ` + ${hiddenCount} on hidden paints` : "") + `. Token coverage: ${Math.round(data.tokenCoverage * 100)}%` + (capped ? " (scan capped \u2014 large subtree)" : ""),
+          data,
+          warnings,
+          recommended_next: unboundColors.length > 0 ? [
+            { tool: "bind_tokens", reason: "Bind unbound colors to design tokens" },
+            { tool: "get_design_tokens", reason: "See available tokens for binding" }
+          ] : [
+            { tool: "analyze_layout_quality", reason: "Check layout quality next" }
+          ]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Analysis failed: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+  server.tool(
+    "analyze_layout_quality",
+    "Check layout quality: auto-layout usage, magic numbers in spacing/padding, and sizing consistency. Use after get_selection_context to find layout improvements. Follow with set_auto_layout to fix issues.",
+    {
+      nodeId: z20.string().optional().describe("Root node to analyze (default: current selection)")
+    },
+    { readOnlyHint: true },
+    async ({ nodeId }) => {
+      try {
+        let targetId;
+        if (nodeId) {
+          targetId = nodeId;
+        } else {
+          const selection = await sendCommand("get_selection");
+          if (!selection?.nodes?.length) return noSelectionError();
+          targetId = selection.nodes[0].id;
+        }
+        const nodeInfo = await sendCommand("get_node_info", { nodeId: targetId, depth: 8, maxNodes: 500 });
+        if (!nodeInfo) {
+          return errorResult2("invalid_input", `Node '${targetId}' not found`, { suggestion: "Use search_nodes", tool: "search_nodes" });
+        }
+        const issues = [];
+        let totalFrames = 0;
+        let autoLayoutCount = 0;
+        analyzeLayoutNode(nodeInfo, issues, { totalFrames: 0, autoLayoutCount: 0 });
+        const frameNodes = collectFrames(nodeInfo);
+        totalFrames = frameNodes.length;
+        autoLayoutCount = frameNodes.filter((f) => f.layoutMode && f.layoutMode !== "NONE").length;
+        const data = {
+          totalFrames,
+          autoLayoutCount,
+          autoLayoutCoverage: totalFrames > 0 ? Math.round(autoLayoutCount / totalFrames * 100) / 100 : 1,
+          issues
+        };
+        return standardResult({
+          summary: `Layout audit: ${autoLayoutCount}/${totalFrames} frames use auto-layout (${Math.round(data.autoLayoutCoverage * 100)}%). ${issues.length} issue(s) found.`,
+          data,
+          warnings: issues.filter((i) => i.severity === "warning").map((i) => ({
+            category: "layout",
+            message: i.issue,
+            nodeId: i.nodeId
+          })),
+          recommended_next: issues.length > 0 ? [{ tool: "set_auto_layout", reason: "Fix layout issues on specific frames" }] : [{ tool: "analyze_color_usage", reason: "Check color token coverage next" }]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Analysis failed: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+  server.tool(
+    "analyze_component_health",
+    "Check component system health: detached instances, unused components, and override consistency. Use to audit design system adherence. Follow with create_component or update_instance to fix issues.",
+    {
+      nodeId: z20.string().optional().describe("Scope to analyze (default: current page)")
+    },
+    { readOnlyHint: true },
+    async ({ nodeId }) => {
+      try {
+        const [instances, components] = await Promise.all([
+          sendCommand("scan_nodes_by_types", {
+            types: ["INSTANCE"],
+            parentId: nodeId
+          }, 12e4),
+          sendCommand("get_local_components")
+        ]);
+        const instanceList = Array.isArray(instances) ? instances : [];
+        const componentList = Array.isArray(components) ? components : [];
+        const issues = [];
+        let detachedCount = 0;
+        for (const inst of instanceList) {
+          if (!inst.mainComponent && !inst.componentId) {
+            detachedCount++;
+            issues.push({
+              nodeId: inst.id,
+              nodeName: inst.name,
+              issue: "Instance appears detached from its main component"
+            });
+          }
+        }
+        const data = {
+          totalComponents: componentList.length,
+          totalInstances: instanceList.length,
+          detachedCount,
+          issues
+        };
+        return standardResult({
+          summary: `Components: ${componentList.length} defined, ${instanceList.length} instances, ${detachedCount} potentially detached`,
+          data,
+          recommended_next: [
+            { tool: "get_design_tokens", reason: "Review design system completeness" },
+            { tool: "search_nodes", reason: "Find specific components by name" }
+          ]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Analysis failed: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+  server.tool(
+    "analyze_accessibility",
+    "Check accessibility: text contrast ratios against backgrounds, touch target sizes. Use to ensure designs meet WCAG guidelines. Follow with update_node to fix contrast or sizing issues.",
+    {
+      nodeId: z20.string().optional().describe("Root node to analyze (default: current selection)")
+    },
+    { readOnlyHint: true },
+    async ({ nodeId }) => {
+      try {
+        let targetId;
+        if (nodeId) {
+          targetId = nodeId;
+        } else {
+          const selection = await sendCommand("get_selection");
+          if (!selection?.nodes?.length) return noSelectionError();
+          targetId = selection.nodes[0].id;
+        }
+        const nodeInfo = await sendCommand("get_node_info", { nodeId: targetId, depth: 8, maxNodes: 500 });
+        if (!nodeInfo) {
+          return errorResult2("invalid_input", `Node '${targetId}' not found`, { suggestion: "Use search_nodes", tool: "search_nodes" });
+        }
+        const issues = [];
+        checkAccessibility(nodeInfo, null, issues);
+        const data = {
+          issueCount: issues.length,
+          issues
+        };
+        return standardResult({
+          summary: `Accessibility: ${issues.length} issue(s) found`,
+          data,
+          warnings: issues.map((i) => ({
+            category: "accessibility",
+            message: i.issue,
+            nodeId: i.nodeId
+          })),
+          recommended_next: issues.length > 0 ? [{ tool: "update_node", reason: "Fix accessibility issues" }] : [{ tool: "validate_design_rules", reason: "Run full design validation" }]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Analysis failed: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+  const CHECKPOINT_KEY = "relai.checkpoint";
+  server.tool(
+    "diff_nodes",
+    `Compare two nodes and list their differences (fills, strokes, size, layout, etc.), or audit changes over time with checkpoints: checkpoint:"save" snapshots nodeIdA's key properties; checkpoint:"compare" later diffs the current state against that snapshot \u2014 useful before/after an editing session to show the designer exactly what changed.`,
+    {
+      nodeIdA: z20.string().describe("First node ID (or the checkpoint target)"),
+      nodeIdB: z20.string().optional().describe("Second node ID (omit when using checkpoint)"),
+      checkpoint: z20.enum(["save", "compare"]).optional().describe("save: snapshot nodeIdA now; compare: diff current vs saved snapshot")
+    },
+    { readOnlyHint: true },
+    async ({ nodeIdA, nodeIdB, checkpoint }) => {
+      try {
+        if (checkpoint === "save") {
+          const node = await sendCommand("get_node_info", { nodeId: nodeIdA, depth: 2 });
+          if (!node) return errorResult2("invalid_input", `Node '${nodeIdA}' not found`, { suggestion: "Check node ID", tool: "search_nodes" });
+          const summary = normalizeNode(node);
+          await sendCommand("set_plugin_data", {
+            nodeId: nodeIdA,
+            key: CHECKPOINT_KEY,
+            value: JSON.stringify({ ts: Date.now(), name: node.name, summary })
+          });
+          return standardResult({
+            summary: `Checkpoint saved for '${node.name}' (${nodeIdA}). Run diff_nodes with checkpoint:"compare" after editing to see what changed.`,
+            data: { nodeId: nodeIdA, saved: true },
+            recommended_next: []
+          });
+        }
+        if (checkpoint === "compare") {
+          const [node, stored] = await Promise.all([
+            sendCommand("get_node_info", { nodeId: nodeIdA, depth: 2 }),
+            sendCommand("get_plugin_data", { nodeId: nodeIdA, key: CHECKPOINT_KEY })
+          ]);
+          if (!node) return errorResult2("invalid_input", `Node '${nodeIdA}' not found`, { suggestion: "Check node ID", tool: "search_nodes" });
+          const raw = typeof stored === "string" ? stored : stored?.value;
+          if (!raw) {
+            return errorResult2("invalid_input", `No checkpoint saved on '${nodeIdA}'`, {
+              suggestion: 'Save one first with checkpoint:"save"',
+              tool: "diff_nodes"
+            });
+          }
+          const saved = JSON.parse(raw);
+          const before = saved.summary;
+          const after = normalizeNode(node);
+          const differences2 = [];
+          if (before && after) {
+            compareField(differences2, "type", before.type, after.type);
+            compareField(differences2, "fill", before.fill, after.fill);
+            compareField(differences2, "stroke", before.stroke, after.stroke);
+            compareField(differences2, "cornerRadius", before.cornerRadius, after.cornerRadius);
+            compareField(differences2, "opacity", before.opacity, after.opacity);
+            compareField(differences2, "width", before.size?.width, after.size.width);
+            compareField(differences2, "height", before.size?.height, after.size.height);
+            compareField(differences2, "layout.mode", before.layout?.mode, after.layout?.mode);
+            compareField(differences2, "layout.gap", before.layout?.gap, after.layout?.gap);
+            compareField(differences2, "layout.padding", before.layout?.padding, after.layout?.padding);
+          }
+          const age = Math.round((Date.now() - (saved.ts ?? Date.now())) / 1e3);
+          return standardResult({
+            summary: differences2.length === 0 ? `'${node.name}' is unchanged since the checkpoint ${age}s ago` : `${differences2.length} propert${differences2.length === 1 ? "y" : "ies"} changed on '${node.name}' since the checkpoint ${age}s ago`,
+            data: {
+              nodeId: nodeIdA,
+              checkpointTs: saved.ts,
+              identical: differences2.length === 0,
+              differences: differences2
+            },
+            recommended_next: []
+          });
+        }
+        if (!nodeIdB) {
+          return errorResult2("invalid_input", 'Provide nodeIdB, or use checkpoint:"save"/"compare" with nodeIdA alone', {
+            suggestion: "Two-node diff needs both ids",
+            tool: "diff_nodes"
+          });
+        }
+        const [nodeA, nodeB] = await Promise.all([
+          sendCommand("get_node_info", { nodeId: nodeIdA, depth: 2 }),
+          sendCommand("get_node_info", { nodeId: nodeIdB, depth: 2 })
+        ]);
+        if (!nodeA) return errorResult2("invalid_input", `Node '${nodeIdA}' not found`, { suggestion: "Check node ID", tool: "search_nodes" });
+        if (!nodeB) return errorResult2("invalid_input", `Node '${nodeIdB}' not found`, { suggestion: "Check node ID", tool: "search_nodes" });
+        const summaryA = normalizeNode(nodeA);
+        const summaryB = normalizeNode(nodeB);
+        const differences = [];
+        if (summaryA && summaryB) {
+          compareField(differences, "type", summaryA.type, summaryB.type);
+          compareField(differences, "fill", summaryA.fill, summaryB.fill);
+          compareField(differences, "stroke", summaryA.stroke, summaryB.stroke);
+          compareField(differences, "cornerRadius", summaryA.cornerRadius, summaryB.cornerRadius);
+          compareField(differences, "opacity", summaryA.opacity, summaryB.opacity);
+          compareField(differences, "width", summaryA.size.width, summaryB.size.width);
+          compareField(differences, "height", summaryA.size.height, summaryB.size.height);
+          compareField(differences, "layout.mode", summaryA.layout?.mode, summaryB.layout?.mode);
+          compareField(differences, "layout.gap", summaryA.layout?.gap, summaryB.layout?.gap);
+          compareField(differences, "layout.padding", summaryA.layout?.padding, summaryB.layout?.padding);
+        }
+        const data = {
+          nodeA: { id: nodeIdA, name: nodeA.name },
+          nodeB: { id: nodeIdB, name: nodeB.name },
+          identical: differences.length === 0,
+          differences
+        };
+        return standardResult({
+          summary: differences.length === 0 ? `'${nodeA.name}' and '${nodeB.name}' are identical in key properties` : `${differences.length} difference(s) between '${nodeA.name}' and '${nodeB.name}'`,
+          data,
+          recommended_next: differences.length > 0 ? [{ tool: "update_node", reason: "Align properties between nodes" }] : []
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Diff failed: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+}
+function collectColorIssues(node, boundVars, issues, counters) {
+  if (node.fills?.length > 0) {
+    const solidFills = node.fills.filter((f) => f.type === "SOLID" && f.visible !== false);
+    if (solidFills.length > 0) {
+      counters.totalProps++;
+      const hasFillBinding = Object.keys(boundVars).some((k) => k.startsWith("fills"));
+      if (hasFillBinding) {
+        counters.boundCount++;
+      } else {
+        for (const fill of solidFills) {
+          if (!fill.color) continue;
+          const color = typeof fill.color === "string" ? fill.color : rgbaToHex({
+            r: fill.color.r,
+            g: fill.color.g,
+            b: fill.color.b,
+            a: fill.color.a ?? 1
+          });
+          issues.push({
+            nodeId: node.id,
+            nodeName: node.name,
+            property: "fill",
+            color
+          });
+        }
+      }
+    }
+  }
+  if (node.strokes?.length > 0) {
+    const solidStrokes = node.strokes.filter((s) => s.type === "SOLID" && s.visible !== false);
+    if (solidStrokes.length > 0) {
+      counters.totalProps++;
+      const hasStrokeBinding = Object.keys(boundVars).some((k) => k.startsWith("strokes"));
+      if (hasStrokeBinding) {
+        counters.boundCount++;
+      } else {
+        for (const stroke of solidStrokes) {
+          if (!stroke.color) continue;
+          const color = typeof stroke.color === "string" ? stroke.color : rgbaToHex({
+            r: stroke.color.r,
+            g: stroke.color.g,
+            b: stroke.color.b,
+            a: stroke.color.a ?? 1
+          });
+          issues.push({
+            nodeId: node.id,
+            nodeName: node.name,
+            property: "stroke",
+            color
+          });
+        }
+      }
+    }
+  }
+}
+function collectFrames(node) {
+  const frames = [];
+  if (node.type === "FRAME" || node.type === "COMPONENT" || node.type === "COMPONENT_SET") {
+    frames.push(node);
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      frames.push(...collectFrames(child));
+    }
+  }
+  return frames;
+}
+function analyzeLayoutNode(node, issues, _counters) {
+  if (node.type === "FRAME" || node.type === "COMPONENT") {
+    if (!node.layoutMode || node.layoutMode === "NONE") {
+      if (node.children?.length >= 2) {
+        issues.push({
+          nodeId: node.id,
+          nodeName: node.name,
+          issue: `Frame '${node.name}' has ${node.children.length} children but no auto-layout`,
+          severity: "warning",
+          suggestion: "Add auto-layout with set_auto_layout for responsive behavior"
+        });
+      }
+    }
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      analyzeLayoutNode(child, issues, _counters);
+    }
+  }
+}
+function checkAccessibility(node, parentBg, issues) {
+  if (node.type === "INSTANCE" || node.name?.toLowerCase().includes("button")) {
+    const w = node.width ?? node.absoluteBoundingBox?.width ?? 0;
+    const h = node.height ?? node.absoluteBoundingBox?.height ?? 0;
+    if (w > 0 && w < 44 || h > 0 && h < 44) {
+      issues.push({
+        nodeId: node.id,
+        nodeName: node.name,
+        issue: `Touch target too small: ${Math.round(w)}\xD7${Math.round(h)}px (minimum 44\xD744px)`
+      });
+    }
+  }
+  if (node.type === "TEXT") {
+    const fontSize = typeof node.fontSize === "number" ? node.fontSize : null;
+    const fontWeight = typeof node.fontWeight === "number" ? node.fontWeight : 400;
+    if (fontSize !== null && fontSize < 11) {
+      issues.push({
+        nodeId: node.id,
+        nodeName: node.name,
+        issue: `Text size ${fontSize}px is below the 11px readability floor`
+      });
+    }
+    const textFill = node.fills?.find((f) => f.type === "SOLID" && f.visible !== false);
+    if (textFill?.color && parentBg?.color) {
+      if (parentBg.solid) {
+        const alpha = (textFill.opacity ?? 1) * (typeof node.opacity === "number" ? node.opacity : 1) * (textFill.color.a ?? 1);
+        const effective = blendOver(textFill.color, parentBg.color, alpha);
+        const isLarge = fontSize !== null && (fontSize >= 24 || fontSize >= 18.66 && fontWeight >= 700);
+        const required = isLarge ? 3 : 4.5;
+        const ratio = calculateContrastRatio(effective, parentBg.color);
+        if (ratio < required) {
+          issues.push({
+            nodeId: node.id,
+            nodeName: node.name,
+            issue: `Low contrast ratio: ${ratio.toFixed(1)}:1 (minimum ${required}:1 for ${isLarge ? "large" : "body"} text${alpha < 1 ? ", opacity included" : ""})`,
+            contrastRatio: Math.round(ratio * 10) / 10,
+            requiredRatio: required
+          });
+        }
+      } else {
+        issues.push({
+          nodeId: node.id,
+          nodeName: node.name,
+          issue: `Text sits on a ${parentBg.kind} background \u2014 contrast cannot be verified automatically; check manually or add a solid scrim`
+        });
+      }
+    }
+  }
+  let bg = parentBg;
+  if (node.type !== "TEXT" && node.fills?.length > 0) {
+    const visible = node.fills.filter((f) => f.visible !== false);
+    const solid = visible.find((f) => f.type === "SOLID");
+    const nonSolid = visible.find((f) => f.type !== "SOLID");
+    if (nonSolid) {
+      const type = String(nonSolid.type ?? "IMAGE");
+      bg = {
+        color: solid?.color ?? { r: 0.5, g: 0.5, b: 0.5 },
+        solid: false,
+        kind: type.startsWith("GRADIENT") ? "gradient" : type.toLowerCase()
+      };
+    } else if (solid?.color) {
+      bg = { color: solid.color, solid: true, kind: "solid" };
+    }
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      checkAccessibility(child, bg, issues);
+    }
+  }
+}
+function blendOver(fg, bg, alpha) {
+  const a = Math.max(0, Math.min(1, alpha));
+  return {
+    r: fg.r * a + bg.r * (1 - a),
+    g: fg.g * a + bg.g * (1 - a),
+    b: fg.b * a + bg.b * (1 - a)
+  };
+}
+function calculateContrastRatio(fg, bg) {
+  const fgL = relativeLuminance(fg.r ?? 0, fg.g ?? 0, fg.b ?? 0);
+  const bgL = relativeLuminance(bg.r ?? 0, bg.g ?? 0, bg.b ?? 0);
+  const lighter = Math.max(fgL, bgL);
+  const darker = Math.min(fgL, bgL);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function relativeLuminance(r, g, b) {
+  const rL = r <= 0.03928 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4);
+  const gL = g <= 0.03928 ? g / 12.92 : Math.pow((g + 0.055) / 1.055, 2.4);
+  const bL = b <= 0.03928 ? b / 12.92 : Math.pow((b + 0.055) / 1.055, 2.4);
+  return 0.2126 * rL + 0.7152 * gL + 0.0722 * bL;
+}
+function compareField(diffs, field, a, b) {
+  if (a !== b) {
+    diffs.push({ field, nodeA: a, nodeB: b });
+  }
+}
+
+// src/tools/v2/verification.ts
+var verification_exports = {};
+__export(verification_exports, {
+  register: () => register20
+});
+import { z as z21 } from "zod";
+function register20(server, sendCommand) {
+  server.tool(
+    "verify_changes",
+    "Verify that a node's current properties match expected values. Use after update_node, set_auto_layout, or batch_execute to confirm changes applied correctly. Returns match/mismatch for each checked field.",
+    {
+      nodeId: z21.string().describe("Node ID to verify"),
+      expected: z21.record(z21.string(), z21.unknown()).describe("Expected property values, e.g. { fill: '#3B82F6', cornerRadius: 8 }")
+    },
+    { readOnlyHint: true },
+    async ({ nodeId, expected }) => {
+      try {
+        const nodeInfo = await sendCommand("get_node_info", { nodeId, depth: 2 });
+        if (!nodeInfo) {
+          return errorResult2(
+            "invalid_input",
+            `Node '${nodeId}' not found \u2014 it may have been deleted`,
+            { suggestion: "Use search_nodes to find the node", tool: "search_nodes" }
+          );
+        }
+        const normalized = normalizeNode(nodeInfo);
+        if (!normalized) {
+          return errorResult2(
+            "invalid_input",
+            `Could not normalize node '${nodeId}'`,
+            { suggestion: "Try get_node_details for raw data", tool: "get_node_details", args: { nodeId } }
+          );
+        }
+        const fields = [];
+        for (const [key, expectedValue] of Object.entries(expected)) {
+          const actual = getNestedValue(normalized, nodeInfo, key);
+          const match = deepEqual(actual, expectedValue);
+          fields.push({ field: key, expected: expectedValue, actual, match });
+        }
+        const allMatch = fields.every((f) => f.match);
+        const data = {
+          nodeId,
+          allMatch,
+          fields
+        };
+        return standardResult({
+          summary: allMatch ? `All ${fields.length} checked properties match expected values` : `${fields.filter((f) => !f.match).length} of ${fields.length} properties don't match expected values`,
+          data,
+          recommended_next: allMatch ? [{ tool: "screenshot", reason: "Visually confirm the changes" }] : [{ tool: "update_node", reason: "Re-apply changes that didn't match", args: { nodeId } }]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Verification failed: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+  server.tool(
+    "validate_design_rules",
+    "Run design quality rules on a node: token coverage, auto-layout usage, naming conventions, and accessibility basics. Use after modifications or during design audits. Returns pass/fail for each rule with fix suggestions.",
+    {
+      nodeId: z21.string().optional().describe("Root node to validate (default: current selection)")
+    },
+    { readOnlyHint: true },
+    async ({ nodeId }) => {
+      try {
+        let targetId;
+        if (nodeId) {
+          targetId = nodeId;
+        } else {
+          const selection = await sendCommand("get_selection");
+          if (!selection?.nodes?.length) return noSelectionError();
+          targetId = selection.nodes[0].id;
+        }
+        const [nodeInfo, boundVars] = await Promise.all([
+          sendCommand("get_node_info", { nodeId: targetId, depth: 2 }),
+          sendCommand("get_bound_variables", { nodeId: targetId }).catch(() => null)
+        ]);
+        if (!nodeInfo) {
+          return errorResult2("invalid_input", `Node '${targetId}' not found`, { suggestion: "Use search_nodes", tool: "search_nodes" });
+        }
+        const bv = boundVars?.boundVariables || {};
+        const results = [];
+        const coverage = calculateTokenCoverage(nodeInfo, bv);
+        results.push({
+          rule: "token_coverage",
+          passed: coverage >= 0.8,
+          severity: coverage >= 0.5 ? "warning" : "error",
+          message: `Token coverage: ${Math.round(coverage * 100)}% (target: 80%+)`,
+          nodeId: targetId,
+          fix: coverage < 0.8 ? { tool: "bind_tokens", reason: "Bind unbound properties to design tokens", args: { nodeId: targetId } } : void 0
+        });
+        if (nodeInfo.type === "FRAME" || nodeInfo.type === "COMPONENT") {
+          const hasAutoLayout = nodeInfo.layoutMode && nodeInfo.layoutMode !== "NONE";
+          const hasChildren = nodeInfo.children?.length >= 2;
+          results.push({
+            rule: "auto_layout",
+            passed: hasAutoLayout || !hasChildren,
+            severity: "warning",
+            message: hasAutoLayout ? `Auto-layout: ${nodeInfo.layoutMode}` : hasChildren ? `No auto-layout on frame with ${nodeInfo.children.length} children` : "No children requiring auto-layout",
+            nodeId: targetId,
+            fix: !hasAutoLayout && hasChildren ? { tool: "set_auto_layout", reason: "Add auto-layout for responsive behavior", args: { nodeId: targetId } } : void 0
+          });
+        }
+        const hasDefaultName = /^(Frame|Rectangle|Ellipse|Group|Text|Vector|Line|Polygon|Star)\s*\d*$/.test(nodeInfo.name);
+        results.push({
+          rule: "naming_convention",
+          passed: !hasDefaultName,
+          severity: "info",
+          message: hasDefaultName ? `'${nodeInfo.name}' uses a default Figma name \u2014 rename for clarity` : `Name '${nodeInfo.name}' looks intentional`,
+          nodeId: targetId,
+          fix: hasDefaultName ? { tool: "update_node", reason: "Rename with a semantic name", args: { nodeId: targetId } } : void 0
+        });
+        if (nodeInfo.type === "INSTANCE" || nodeInfo.name?.toLowerCase().includes("button")) {
+          const w = nodeInfo.width ?? 0;
+          const h = nodeInfo.height ?? 0;
+          const adequate = w >= 44 && h >= 44;
+          results.push({
+            rule: "touch_target_size",
+            passed: adequate,
+            severity: "warning",
+            message: adequate ? `Touch target: ${Math.round(w)}\xD7${Math.round(h)}px (OK)` : `Touch target: ${Math.round(w)}\xD7${Math.round(h)}px (minimum 44\xD744px)`,
+            nodeId: targetId,
+            fix: !adequate ? { tool: "update_node", reason: "Increase size to meet touch target minimum", args: { nodeId: targetId } } : void 0
+          });
+        }
+        try {
+          const orph = await sendCommand("find_orphan_instances", { nodeId: targetId }, 6e4);
+          if (orph && typeof orph.scanned === "number") {
+            const found = orph.orphans ?? [];
+            results.push({
+              rule: "orphaned_instances",
+              passed: found.length === 0,
+              severity: "warning",
+              message: found.length ? `${found.length} instance(s) reference deleted components (of ${orph.scanned} scanned): ${found.slice(0, 3).map((o) => o.name).join(", ")}${found.length > 3 ? "\u2026" : ""}` : `No orphaned instances (${orph.scanned} scanned)`,
+              nodeId: targetId,
+              fix: found.length ? { tool: "manage_components", reason: "Re-instantiate from a living component, or detach deliberately", args: { action: "list" } } : void 0
+            });
+          }
+        } catch {
+        }
+        const passed = results.filter((r) => r.passed).length;
+        const failed = results.filter((r) => !r.passed).length;
+        const data = {
+          rulesChecked: results.length,
+          passed,
+          failed,
+          results
+        };
+        return standardResult({
+          summary: `Design validation: ${passed}/${results.length} rules passed, ${failed} failed`,
+          data,
+          recommended_next: failed > 0 ? results.filter((r) => !r.passed && r.fix).map((r) => r.fix).slice(0, 3) : [{ tool: "screenshot", reason: "Visually confirm the design quality" }]
+        });
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Validation failed: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+  server.tool(
+    "verify_visual",
+    "The write\u2192see\u2192assert loop in one call: screenshots a node AND (optionally) checks expected property values. Returns the image plus structured pass/fail. Use after visual edits instead of separate screenshot + verify_changes calls.",
+    {
+      nodeId: z21.string().describe("Node to verify"),
+      expected: z21.record(z21.string(), z21.unknown()).optional().describe("Expected property values, e.g. { cornerRadius: 8, width: 320 }")
+    },
+    { readOnlyHint: true },
+    async ({ nodeId, expected }) => {
+      try {
+        const [shot, nodeInfo] = await Promise.all([
+          sendCommand("get_screenshot", { nodeId }, 6e4),
+          expected ? sendCommand("get_node_info", { nodeId, depth: 2 }) : Promise.resolve(null)
+        ]);
+        const content = [];
+        if (shot?.imageData) {
+          content.push({
+            type: "image",
+            data: shot.imageData,
+            mimeType: shot.mimeType ?? "image/png"
+          });
+        }
+        if (expected && nodeInfo) {
+          const normalized = normalizeNode(nodeInfo) ?? {};
+          const fields = Object.entries(expected).map(([key, expectedValue]) => {
+            const actual = getNestedValue(normalized, nodeInfo, key);
+            return { field: key, expected: expectedValue, actual, match: deepEqual(actual, expectedValue) };
+          });
+          const failing = fields.filter((f) => !f.match);
+          content.push({
+            type: "text",
+            text: JSON.stringify(
+              {
+                summary: failing.length === 0 ? `All ${fields.length} checked properties match \u2014 confirm the screenshot looks right` : `${failing.length}/${fields.length} properties do NOT match`,
+                fields
+              },
+              null,
+              2
+            )
+          });
+        } else if (!shot?.imageData) {
+          content.push({ type: "text", text: "Screenshot unavailable for this node." });
+        }
+        return { content };
+      } catch (error) {
+        return errorResult2(
+          "connection_error",
+          `Visual verification failed: ${error instanceof Error ? error.message : String(error)}`,
+          { suggestion: "Ensure Figma plugin is connected", tool: "join_room" }
+        );
+      }
+    }
+  );
+}
+function getNestedValue(normalized, raw, key) {
+  if (key in normalized) return normalized[key];
+  if (key === "width") return normalized.size?.width;
+  if (key === "height") return normalized.size?.height;
+  if (key === "x") return normalized.position?.x;
+  if (key === "y") return normalized.position?.y;
+  return raw[key];
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a === "number" && typeof b === "number") {
+    return Math.abs(a - b) < 0.01;
+  }
+  if (typeof a === "string" && typeof b === "string") {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+// src/tools/index.ts
+var moduleCategories = [
+  [context_exports, "context"],
+  [analysis_exports, "analysis"],
+  [verification_exports, "verification"],
+  [read_exports, "read"],
+  [create_exports, "create"],
+  [properties_exports, "edit"],
+  [structure_exports, "edit"],
+  [text_exports, "edit"],
+  [components_exports, "components"],
+  [variables_exports, "design-system"],
+  [styles_exports, "design-system"],
+  [library_exports, "design-system"],
+  [design_system_exports, "design-system"],
+  [pages_exports, "document"],
+  [navigate_exports, "document"],
+  [assets_exports, "assets"],
+  [annotate_exports, "annotations"],
+  [comments_exports, "comments"],
+  [batch_exports, "advanced"],
+  [execute_exports, "advanced"]
+];
+function registerRoomTool(server, joinRoom) {
+  server.tool(
+    "join_room",
+    "Connect to a specific Figma plugin instance by room name. Usually unnecessary \u2014 pairing is automatic when one plugin is connected. Use only when an error reports multiple plugins/rooms; the room name is shown in each plugin's UI.",
+    {
+      room: z22.string().describe("Room name shown in the Figma plugin")
+    },
+    async ({ room }) => {
+      try {
+        if (!room) {
+          return {
+            content: [{ type: "text", text: "Please provide a room name." }]
+          };
+        }
+        await joinRoom(room);
+        return {
+          content: [
+            { type: "text", text: `Successfully joined room: ${room}` }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error joining room: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+function registerEventsTool(server, consumeEvents, getSessionLog) {
+  server.tool(
+    "get_events",
+    "Activity since the last check. scope 'designer' (default): the designer's selection/node/page changes (also piggybacked as designer_events on command results). scope 'agent': this session's own command log \u2014 every plugin command sent, with success/duration \u2014 useful for summarizing what was changed. 'all': both.",
+    {
+      scope: z22.enum(["designer", "agent", "all"]).optional()
+    },
+    { readOnlyHint: true },
+    async ({ scope = "designer" }) => {
+      const parts = {};
+      if (scope === "designer" || scope === "all") {
+        parts.designer_events = consumeEvents();
+      }
+      if (scope === "agent" || scope === "all") {
+        parts.session_log = getSessionLog();
+      }
+      const empty = Object.values(parts).every((v) => Array.isArray(v) && v.length === 0);
+      return {
+        content: [
+          {
+            type: "text",
+            text: empty ? "No activity recorded." : JSON.stringify(parts, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+function registerAllTools(server, sendCommand) {
+  for (const [mod] of moduleCategories) {
+    mod.register(server, sendCommand);
+  }
+}
+function listToolCatalog() {
+  const catalog = [
+    { name: "join_room", category: "advanced" },
+    { name: "get_events", category: "context" }
+  ];
+  for (const [mod, category] of moduleCategories) {
+    const collector = {
+      tool: (name) => {
+        catalog.push({ name, category });
+      }
+    };
+    mod.register(collector, async () => void 0);
+  }
+  return catalog;
+}
+
+// ../../docs/skills/figma-plugin-api.md
+var figma_plugin_api_default = '# Figma Plugin API Cheat Sheet \u2014 for `execute_figma`\n\nRules and patterns for writing code that runs in the plugin sandbox. Work in small incremental scripts and `screenshot` between steps.\n\n## Non-negotiable rules (dynamic-page mode)\n\n- **Node lookup is async**: `await figma.getNodeByIdAsync(id)` \u2014 `getNodeById` throws in this plugin.\n- **Load pages before traversal**: `await page.loadAsync()` before `page.findAll(...)` on a non-current page; `figma.currentPage` is always loaded.\n- **Load fonts before ANY text edit**: `await figma.loadFontAsync(textNode.fontName)` \u2014 if `fontName === figma.mixed`, load every range: `for (const f of textNode.getRangeAllFontNames(0, textNode.characters.length)) await figma.loadFontAsync(f)`.\n- **`figma.mixed` is a Symbol**: properties like `fontSize`, `cornerRadius`, `fills` return it when values differ across ranges/children. Check `=== figma.mixed` before using; never JSON-serialize it.\n\n## Common patterns\n\n```js\n// Selection\nconst sel = figma.currentPage.selection;          // read\nfigma.currentPage.selection = [node];             // write\n\n// Create + place\nconst frame = figma.createFrame();\nframe.resize(320, 200);                            // width/height are read-only; use resize()\nparent.appendChild(frame);                         // default parent is currentPage\n\n// Fills/strokes are ARRAYS and must be reassigned wholesale\nnode.fills = [{ type: "SOLID", color: { r: 1, g: 0.5, b: 0 } }];  // rgb 0-1, no alpha key \u2014 use opacity\nconst fills = JSON.parse(JSON.stringify(node.fills));              // clone before mutating\nfills[0].color.r = 0; node.fills = fills;\n\n// Auto-layout: set layoutMode FIRST, then padding/spacing/align\nframe.layoutMode = "VERTICAL";\nframe.itemSpacing = 8; frame.paddingTop = 16;\nchild.layoutSizingHorizontal = "FILL";             // requires PARENT with auto-layout\n\n// Components\nconst comp = await figma.importComponentByKeyAsync(key);  // team library\nconst inst = comp.createInstance();\ninst.setProperties({ Variant: "Primary" });        // throws on unknown property names\n\n// Variables\nconst collections = await figma.variables.getLocalVariableCollectionsAsync();\nconst v = figma.variables.createVariable("name", collection, "COLOR");\nv.setValueForMode(modeId, { r: 0, g: 0, b: 0 });\nnode.setBoundVariable("fills", v);                 // binding paint needs figma.variables.setBoundVariableForPaint on the paint object for fills in older APIs \u2014 prefer setBoundVariable where available\n\n// Export (returns Uint8Array)\nconst bytes = await node.exportAsync({ format: "PNG", constraint: { type: "SCALE", value: 2 } });\n```\n\n## `relai.*` helpers \u2014 the shortest path is the correct one\n\nAlongside `figma`, scripts get a `relai` object whose helpers are immune to the pitfalls below. Prefer them:\n\n```js\nawait relai.text(parent, "Hello", { font: {family:"IBM Plex Mono", style:"Regular"}, size: 14, color: {r:0,g:0,b:0} });\n                                          // loads the font BEFORE writing characters\nconst card = relai.autoLayout("VERTICAL", { name: "Card", itemSpacing: 8 });\n                                          // auto-layout frame, both axes hugging\nrelai.set(node, { layoutMode: "HORIZONTAL", width: 320, opacity: 0.9 });\n                                          // layoutMode applied first; width/height via resize()\nrelai.hug(node);                          // HUG that sticks \u2014 call after appending children\nrelai.focusRing(button);                  // clipsContent + double spread shadows that render\nconst page = await relai.page(p => p.children.some(c => c.name === "Button"));\n                                          // find pages by CONTENT \u2014 names get renamed\nconst titles = relai.query(\'FRAME[name^=Card] > TEXT\');\n                                          // CSS-like search on the current page; relai.query(node, sel) scopes to a subtree.\n                                          // Supported: TYPE, *, [name=] [name*=] [name^=] [name$=], descendant, >, comma.\n                                          // NOT supported: pseudo-classes, dot-paths, sibling combinators \u2014 use findAll.\nrelai.placeholder(section);               // construction veil so the designer sees work-in-progress\nrelai.placeholder(section, false);        // ALWAYS remove when the section is done\n```\n\nTwo important facts: **scripts are NOT atomic** \u2014 on error, changes made before the throw persist, so keep scripts small and clean up after failures; and results may carry a `warnings` array for silent mistakes the lint catches on relai-created nodes and any node ids you return (e.g. spread shadows on a non-clipping frame). Convention: **return every created/mutated node id** (`return { createdNodeIds: [...] }`) \u2014 it powers both follow-up calls and the lint.\n\n## Pitfalls that throw (or silently do the wrong thing)\n\nWhen one of these throws inside `execute_figma`, the error already carries the remedy as a `Hint:` \u2014 this list is generated from the same registry (`packages/shared/src/pitfalls.ts`).\n\n<!-- PITFALLS:START -->\n- **Editing text without loading its font throws** (`unloaded font`). `await figma.loadFontAsync(textNode.fontName)` first; new TextNodes default to Inter Regular; when `fontName === figma.mixed`, load every font from `getRangeAllFontNames()`.\n- **`getNodeById` throws in dynamic-page mode** \u2014 always `await figma.getNodeByIdAsync(id)`.\n- **Traversing a non-current page throws until you `await page.loadAsync()`** \u2014 `figma.currentPage` is always loaded, other pages are not.\n- **`layoutSizingHorizontal/Vertical` throw without auto-layout** \u2014 FILL requires the parent to have a `layoutMode`, HUG requires it on the node itself.\n- **`createPage()` throws on the free plan once a file has 3 pages** \u2014 reuse an existing page instead.\n- **`width`/`height` are read-only** \u2014 use `node.resize(w, h)`.\n- **`figma.mixed` is a Symbol** returned by `fontSize`, `cornerRadius`, `fills` etc. when values differ across ranges/children \u2014 check `=== figma.mixed` before use; never JSON-serialize it.\n- **Exact-name lookups are fragile** \u2014 designers rename pages and layers freely; locate nodes by type/content instead of `name ===`.\n- **Stale node ids throw `does not exist`** \u2014 nodes get deleted while you work; re-read before editing and check `node.removed`.\n- **Nodes are non-extensible** \u2014 `node.myCustomProp = x` throws `object is not extensible`; use `setPluginData` or return the data instead.\n- **Shadow `spread` renders only on shapes or frames with `clipsContent: true`** \u2014 a focus ring built from spread shadows is invisible on a non-clipping frame/component.\n- **`resize()` on an auto-layout frame silently pins that axis to FIXED**, overriding `primaryAxisSizingMode: "AUTO"`. Append children first, then set `layoutSizingHorizontal = "HUG"`; use `resize` only for the fixed cross-axis.\n- **Per-corner radius** (`topLeftRadius` \u2026) only exists on RectangleCornerMixin nodes (rectangles, frames, components) \u2014 polygons, stars and lines throw.\n- **Instance children can\'t be added or removed** \u2014 detach first, or edit the main component.\n<!-- PITFALLS:END -->\n\nAlso: `resize(w, h)` throws on `w <= 0 || h <= 0`; `layoutWrap = "WRAP"` is HORIZONTAL-only, `counterAxisAlignItems = "BASELINE"` too; writing to `locked` nodes is allowed by the API but surprises designers \u2014 check first.\n\n## Return values\n\nReturn JSON-serializable data (the bridge summarizes nodes automatically and truncates >50k chars). Prefer returning `{ id, name, type }` summaries over whole nodes. `console.log` is captured and returned in `logs`.\n\n---\n\n*Tool parameter contracts are deliberately not duplicated in this document \u2014 every tool is self-describing over MCP, and `npx figma-relai docs <tool>` (or the generated `docs/manifest.json`) is the always-current reference.*\n';
+
+// ../../docs/skills/design-tokens-strategy.md
+var design_tokens_strategy_default = "# Design Tokens Strategy \u2014 4-Tier Token Architecture\n\n## Token Hierarchy\n\n### Tier 1 \u2014 Core (static)\nRaw values. Never referenced directly by components.\n- Naming: `color-static/{hue}/{shade}`, `spacing-static/{value}`\n- Examples: `color-static/slate/50`, `color-static/rose/500`\n- Single mode: Value\n- hiddenFromPublishing: true\n\n### Tier 1 \u2014 Core (dynamic)\nReferences static tokens. Handles Light/Dark inversion.\n- Naming: `color-dynamic/{hue}/{shade}`\n- Light mode: shade 50 \u2192 static/50, shade 900 \u2192 static/900\n- Dark mode: shade 50 \u2192 static/900, shade 900 \u2192 static/50 (inverted)\n- 2 modes: Light / Dark\n- hiddenFromPublishing: true\n\n### Tier 2 \u2014 Themes\nSemantic tokens. Define brand personality.\n- Naming: `color/{role}/{variant}`, `typography/{style}/{property}`, `border/{type}/{size}`\n- Color roles: background, content, border, icon\n- Color variants: surface-page, surface-default, surface-subtle, surface-knockout, disabled, utility/{status}/{emphasis|subtle}\n- Typography: headline-{lg|md|sm}, title-{lg|md}, body-{lg|md|sm}[-bold], label-{lg|md|sm}, code-{md|sm}[-bold]\n- Each typography style has: font-family, font-weight, font-size, letter-spacing, line-height\n- Modes: one per brand (e.g., Brand A, Brand B)\n- description: required \u2014 explain purpose and usage constraints\n- scopes: set appropriately (TEXT_FILL for content, STROKE_COLOR for border, FRAME_FILL for background, etc.)\n\n### Tier 3 \u2014 Components\nComponent-specific tokens. Reference Tier 2 or dynamic Tier 1.\n- Naming: `{component}/color/{role}/{state}`, `{component}/size/{variant}`\n- States: default, hover, pressed, disabled, selected, selected-hover, selected-pressed, selected-disabled\n- Sizes: sm, md, lg\n- Examples: `button/color/background/default`, `button/size/md`, `navigation/color/content/selected`\n- Modes: same as Tier 2 (one per brand)\n- Not every component needs Tier 3 \u2014 only when reuse or shared decision-making justifies it\n\n## Key Rules\n- Components MUST reference tokens only \u2014 never raw hex/px values\n- Tier 1 is internal plumbing \u2014 never expose to consumers\n- Adding a new brand = adding a mode to Tier 2 and Tier 3 collections\n- Light/Dark switching is handled entirely in Tier 1 dynamic \u2014 no brand-level light/dark logic needed\n\n## Workflow\n1. `get_design_tokens` \u2192 understand existing collections and modes\n2. `manage_variables` (list) with collectionId \u2192 inspect current tokens\n3. `manage_variables` (create_collection) \u2192 new collection with modes\n4. `manage_variables` (create) \u2192 define tokens with values per mode\n5. `manage_variables` (bind) \u2192 connect tokens to node properties\n6. `manage_variables` (set_scopes) \u2192 restrict UI picker visibility\n7. `manage_variables` (set_code_syntax) \u2192 set Dev Mode code references\n\n## Verification\n- `analyze_design` (aspect: color) \u2192 find unbound colors (token coverage)\n- `validate_design_rules` \u2192 check token_coverage rule\n- `get_node_data` (detail: variables) on key nodes \u2192 confirm bindings are correct\n\n---\n\n*Tool parameter contracts are deliberately not duplicated in this document \u2014 every tool is self-describing over MCP, and `npx figma-relai docs <tool>` (or the generated `docs/manifest.json`) is the always-current reference.*\n";
+
+// ../../docs/skills/component-architecture-strategy.md
+var component_architecture_strategy_default = "# Component Architecture \u2014 Component Conventions\n\n## Token-First Principle\nEvery visual property must reference a token. No raw values in components.\n- Colors \u2192 Tier 2 semantic tokens or Tier 3 component tokens\n- Sizes (height, spacing) \u2192 Tier 2 or Tier 3 size tokens\n- Typography \u2192 Tier 2 typography tokens\n- Border radius/width \u2192 Tier 2 border tokens\n\n## Tier 3 Token Pattern\nWhen a component needs brand-differentiated values:\n\n`{component}/color/{role}/{state}`\n- Roles: background, border, content\n- States: default, hover, pressed, disabled\n- Selected states: selected, selected-hover, selected-pressed, selected-disabled\n- Variants: primary, ai, critical, ghost (prefix before role)\n\nExample \u2014 Button tokens:\n- `button/color/background/default` \u2192 neutral button bg\n- `button/primary/color/background/hover` \u2192 primary variant hover\n- `button/size/sm` / `button/size/md` / `button/size/lg`\n\n## State Management\nStandard interactive states:\n- default \u2192 hover \u2192 pressed \u2192 disabled (always present)\n- selected \u2192 selected-hover \u2192 selected-pressed \u2192 selected-disabled (for toggleable elements)\n\n## Size Variants\nUse sm / md / lg consistently. Define as Tier 3 FLOAT tokens when brand-differentiated.\n- `{component}/size/sm`, `{component}/size/md`, `{component}/size/lg`\n\n## Component Structure\n1. Use auto-layout (VERTICAL or HORIZONTAL) for all containers\n2. Use HUG for content-driven sizes, FILL for responsive elements\n3. Use component properties for configurable aspects:\n   - BOOLEAN: toggle visibility (icons, labels)\n   - INSTANCE_SWAP: swap nested components\n   - VARIANT: select between variant sets\n   - TEXT: configurable text content\n\n## Workflow\n1. `get_selection_context` \u2192 understand current component structure\n2. `manage_components` (list) \u2192 check existing components\n3. Design the component with auto-layout\n4. Create variants for states using `manage_components` (create_set)\n5. `manage_variables` (bind) \u2192 attach Tier 2/3 tokens to all visual properties\n6. `manage_components` (set_props) \u2192 configure instance properties\n\n## Verification\n- `analyze_design` (aspect: components) \u2192 find detached instances, unused components\n- `verify_changes` \u2192 confirm properties match expected values\n- `get_node_data` (detail: variables) \u2192 ensure all fills/strokes are token-bound\n\n---\n\n*Tool parameter contracts are deliberately not duplicated in this document \u2014 every tool is self-describing over MCP, and `npx figma-relai docs <tool>` (or the generated `docs/manifest.json`) is the always-current reference.*\n";
+
+// ../../docs/skills/design-audit-strategy.md
+var design_audit_strategy_default = "# Design Audit Strategy\n\n## Phase 1: Overview\n1. `get_document_overview` \u2192 pages, component/style/variable counts\n2. `get_design_tokens` \u2192 token system structure (collections, modes, coverage)\n\n## Phase 2: Color & Token Audit\n1. `analyze_design` (aspect: color) \u2192 find colors not backed by variables\n2. `get_node_data` (detail: variables) on key nodes \u2192 verify correct tier references\n3. Check: components should reference Tier 2/3 tokens, never Tier 1 or raw values\n\n## Phase 3: Layout Quality\n1. `analyze_design` (aspect: layout) \u2192 detect missing auto-layout, inconsistent spacing\n2. Check: all containers should use auto-layout (not absolute positioning)\n3. Check: spacing should use token values, not arbitrary px\n\n## Phase 4: Component Health\n1. `analyze_design` (aspect: components) \u2192 detached instances, unused components\n2. `manage_components` (list) \u2192 review component inventory\n3. Check: all instances should be connected to their main component\n\n## Phase 5: Accessibility\n1. `analyze_design` (aspect: accessibility) \u2192 contrast ratios, touch target sizes\n2. Check: minimum contrast 4.5:1 for text, 3:1 for large text\n3. Check: touch targets \u2265 44\xD744px\n\n## Phase 6: Comprehensive Validation\n1. `validate_design_rules` \u2192 runs all checks in one pass:\n   - token_coverage: % of nodes with variable bindings\n   - auto_layout: % of frames using auto-layout\n   - naming_convention: layer naming quality\n   - touch_target_size: minimum size compliance\n\n## Reporting\n- `screenshot` before and after fixes\n- `annotate` (set) / `annotate` (set_multiple) to flag issues directly in the design\n- Summarize findings by severity (critical \u2192 warning \u2192 info)\n\n---\n\n*Tool parameter contracts are deliberately not duplicated in this document \u2014 every tool is self-describing over MCP, and `npx figma-relai docs <tool>` (or the generated `docs/manifest.json`) is the always-current reference.*\n";
+
+// ../../docs/skills/token-audit.md
+var token_audit_default = "# Token Audit \u2014 Token Hierarchy Compliance Check\n\n## Purpose\nVerify that a design correctly uses the 4-tier token hierarchy:\n- No raw color/size values (everything should be token-bound)\n- Correct tier references (components \u2192 Tier 2/3, never Tier 1 directly)\n- Consistent scope usage\n\n## Audit Process\n\n### Step 1: Scope the Audit\n- `get_selection_context` \u2192 identify the area to audit\n- Or `get_document_overview` \u2192 audit the full document\n\n### Step 2: Color Token Coverage\n- `analyze_design` (aspect: color) \u2192 find all colors and whether they're token-bound\n- Flag any raw hex values not backed by variables\n\n### Step 3: Variable Binding Check\n- `get_node_data` (detail: variables) on key nodes \u2192 check what's bound\n- For each binding, verify the variable comes from the correct tier:\n  - \u2705 Component referencing Tier 2 (e.g., `color/content/default`)\n  - \u2705 Component referencing Tier 3 (e.g., `button/color/background/default`)\n  - \u274C Component referencing Tier 1 (e.g., `color-static/slate/500`)\n  - \u274C Component referencing Tier 1 dynamic (e.g., `color-dynamic/slate/500`)\n\n### Step 4: Scope Validation\n- `manage_variables` (list) \u2192 check that scopes are set correctly:\n  - Color content tokens \u2192 TEXT_FILL\n  - Color background tokens \u2192 FRAME_FILL, SHAPE_FILL\n  - Color border tokens \u2192 STROKE_COLOR\n  - Size tokens \u2192 WIDTH_HEIGHT\n  - Border radius \u2192 CORNER_RADIUS\n  - Border width \u2192 STROKE_FLOAT\n\n### Step 5: Comprehensive Check\n- `validate_design_rules` \u2192 run all design rules at once\n\n## Output Format\nReport findings as:\n- **Coverage**: X% of nodes have token bindings\n- **Tier violations**: list of nodes referencing wrong tier\n- **Raw values**: list of unbound colors/sizes with suggested token mappings\n- **Scope issues**: variables with missing or incorrect scopes\n\n---\n\n*Tool parameter contracts are deliberately not duplicated in this document \u2014 every tool is self-describing over MCP, and `npx figma-relai docs <tool>` (or the generated `docs/manifest.json`) is the always-current reference.*\n";
+
+// ../../docs/skills/component-spec.md
+var component_spec_default = "# Component Specification Generator\n\n## Purpose\nGenerate a structured specification document for a component, covering its properties, variants, token bindings, and states.\n\n## Process\n\n### Step 1: Identify the Component\n- `get_selection_context` \u2192 read the selected component/instance\n- Or `search_nodes` by name to find it\n\n### Step 2: Extract Properties\n- `manage_components` (get_props) \u2192 list all configurable properties (VARIANT, BOOLEAN, INSTANCE_SWAP, TEXT)\n- `get_node_details` \u2192 full node structure with children summary\n\n### Step 3: Token Bindings\n- `get_node_data` (detail: variables) \u2192 list all token bindings on the component and its children\n- `manage_variables` (list) \u2192 resolve variable names, descriptions, scopes, codeSyntax\n- Map bindings to the 4-tier token structure\n\n### Step 4: Visual Reference\n- `screenshot` \u2192 capture the component in its default state\n- If variants exist, capture key states (default, hover, disabled, etc.)\n\n### Step 5: Generate Spec\n\nOutput format:\n\n#### {Component Name}\n**Description**: (from context or user input)\n\n**Properties**\n| Name | Type | Values | Default |\n|------|------|--------|---------|\n\n**Token Bindings**\n| Property | Token | Tier | Value (default mode) |\n|----------|-------|------|---------------------|\n\n**States**\n| State | Visual Changes |\n|-------|---------------|\n\n**Size Variants**\n| Size | Height | Token |\n|------|--------|-------|\n\n## Tips\n- For components from a library (remote: true), some properties may be read-only\n- Use `manage_components` (get_overrides) to see what's been customized on instances\n- Include codeSyntax values for developer handoff\n\n---\n\n*Tool parameter contracts are deliberately not duplicated in this document \u2014 every tool is self-describing over MCP, and `npx figma-relai docs <tool>` (or the generated `docs/manifest.json`) is the always-current reference.*\n";
+
+// ../../docs/skills/comment-driven-tasks.md
+var comment_driven_tasks_default = '# Comment-driven tasks\n\nDesigners leave requests as **Figma comments**; you pick them up, do the work, and reply on the thread. This turns Relai into an async collaborator without the designer ever leaving Figma \u2014 comments are their native input surface.\n\n## Honest model\n\nThis is **polling, not a live feed**. An MCP server only acts when called, so requests are noticed when you check \u2014 at the start of a session, when the user says "check the comments", or on a loop the user runs in their own client. Say so if the user expects real-time pickup.\n\nRequires `FIGMA_TOKEN` (personal access token with comment scopes). A free-plan token works on the user\'s own files.\n\n## The loop\n\n1. **Scan** \u2014 `manage_comments` `action:"list"` with `unresolved:true`, plus `since:<checkedAt from the previous scan>` after the first pass. Keep the returned `checkedAt` as the next cursor.\n2. **Select** \u2014 treat a comment as a task when it reads as an instruction ("make this...", "fix...", "@relai ..."). Skip chatter between humans and threads you already replied to (your replies carry your token account\'s handle).\n3. **Anchor** \u2014 pinned comments carry a `nodeId`. Start there: `get_node_details` / `screenshot` for context. Unpinned comments apply to the file broadly; ask before guessing a target.\n4. **Claim** \u2014 reply on the thread *before* working: `action:"reply"` with a one-liner like `\u{1F916} On it \u2014 <what you understood>`. This prevents double-work across sessions and tells the designer they were heard.\n5. **Execute** \u2014 normal Relai flow: design-system first, verify with `verify_visual` / `screenshot`.\n6. **Report back** \u2014 reply on the same thread with what changed and the node ids touched, e.g. `\u{1F916} Done: CTA restyled to primary/600, radius token applied (2 nodes). Reply here if it\'s off.` The REST API cannot mark threads resolved \u2014 the designer resolves it, which doubles as their sign-off.\n\n## One-shot phrasing for users\n\nUsers can drive the whole loop with a single ask: *"Check the file\'s comments and handle anything addressed to you, then report back on each thread."* For a standing loop, they re-issue that ask periodically (or wire it to their client\'s scheduler if it has one).\n\n---\n\n*Tool parameter contracts are deliberately not duplicated in this document \u2014 every tool is self-describing over MCP, and `npx figma-relai docs <tool>` (or the generated `docs/manifest.json`) is the always-current reference.*\n';
+
+// ../../docs/skills/design-system-first.md
+var design_system_first_default = '# Design-system-first building\n\nThe difference between "AI slop" and work a design team accepts is almost always this: **slop draws new shapes; good work reuses the file\'s own system**. Before building any UI in a file that has one, wire yourself to it.\n\n## The sequence\n\n1. **`get_design_system`** \u2014 one call, cached per session. Read what exists: components (sorted by usage \u2014 high-usage items are the file\'s vocabulary), variable collections, styles, and the remote items the file already consumes. If the team\'s library lives in another file and `FIGMA_TOKEN` is set, pass `libraryFileUrl` for the full catalog.\n2. **`manage_conventions` (get)** \u2014 if the file carries conventions, they outrank your defaults. (`get_document_overview` includes them automatically.)\n3. **Compose from instances** \u2014 `manage_components` `action:"instantiate"` with the component key (works for local AND enabled-library keys; remote keys import automatically). Set variants/text via `set_props`. Only draw raw shapes for genuinely new elements.\n4. **Bind, don\'t hardcode** \u2014 colors/spacing/radius come from the file\'s variables (`manage_variables` `action:"bind"`, or variable fields in `set_properties`). If you must hardcode during exploration, run `analyze_design aspect:"tokens"` afterward and fix with `manage_variables action:"tokenize" fix:true`.\n5. **Verify like a designer** \u2014 `screenshot` / `verify_visual` after each increment, not at the end.\n\n## When the file has no system\n\nDon\'t invent variables for a one-off request. But if the work IS system-shaped (a palette, a type scale, components), build variables first, then styles/components on top \u2014 and offer to record naming decisions in `manage_conventions`.\n\n## Signals you\'re drifting\n\n- You drew a rectangle that looks like an existing Button/Card/Badge \u2192 replace it with an instance.\n- A hex value appears in your code that `get_design_system` lists as a variable \u2192 bind instead.\n- You renamed or restructured library instances the designer didn\'t ask about \u2192 undo; instances belong to their component.\n\n---\n\n*Tool parameter contracts are deliberately not duplicated in this document \u2014 every tool is self-describing over MCP, and `npx figma-relai docs <tool>` (or the generated `docs/manifest.json`) is the always-current reference.*\n';
+
+// ../../docs/skills/janitorial-cleanup.md
+var janitorial_cleanup_default = '# Janitorial cleanup\n\nThe chores designers postpone for months \u2014 layer renaming, token drift, spacing normalization \u2014 are where an agent earns trust fastest. These jobs are big, mechanical, and easy to verify. Do them conservatively and loudly.\n\n## Ground rules\n\n- **Preview before bulk.** Use `dryRun:true` on `batch_execute` / `set_properties`, or report findings first (`analyze_design`), and tell the designer the scale ("about 140 renames on this page \u2014 go?"). If the plugin\'s approval gate is on, big writes will ask them anyway.\n- **Scope tightly.** Work page by page (or within the designer\'s selection). Never sweep the whole file unasked.\n- **Never rename or restyle library instances\' internals** \u2014 only top-level frames/groups the team owns.\n\n## Recipes\n\n### Rename layers by content\n`Frame 427` tells nobody anything. Walk the target scope with `execute_figma` + `relai.query`, and derive names:\n- A frame whose only text child says "Submit" \u2192 `Button/Submit` (match the file\'s existing naming pattern from `get_design_system`, don\'t invent one).\n- Text nodes \u2192 their content, truncated (`Heading: Pricing plans`).\n- Skip nodes that already have deliberate names (anything not matching `/^(Frame|Group|Rectangle|Ellipse|Vector|Line) \\d+$/`).\nReturn the rename list; apply via one `batch_execute` of `rename_node` commands.\n\n### Tokenize hardcoded values\n`analyze_design aspect:"tokens"` finds hardcoded colors/numbers that visually match existing variables; `manage_variables action:"tokenize" fix:true` binds them in one pass. Report anything close-but-not-matching (deltaE just over tolerance) instead of silently snapping it.\n\n### Normalize spacing\nIn auto-layout scopes, collect `itemSpacing`/padding values; flag off-scale values (not on the file\'s 4/8pt grid or spacing variables) and propose the nearest on-scale value. Apply only after the designer confirms the mapping.\n\n### Sweep detached instances\n`analyze_design aspect:"components"` lists likely-detached instances. Offer to re-link obvious ones (matching component still exists) and just report the rest \u2014 re-attaching wrong is worse than detached.\n\n## Report format\n\nEnd with counts and jump-points: what changed, what was skipped and why, node ids for spot-checking (the designer can click entries in the plugin feed).\n\n---\n\n*Tool parameter contracts are deliberately not duplicated in this document \u2014 every tool is self-describing over MCP, and `npx figma-relai docs <tool>` (or the generated `docs/manifest.json`) is the always-current reference.*\n';
+
+// src/prompts.ts
+var SKILLS = [
+  [
+    "figma-plugin-api",
+    "Cheat sheet for writing execute_figma code: dynamic-page rules, font loading, auto-layout pitfalls, common patterns. Load before non-trivial execute_figma work.",
+    figma_plugin_api_default
+  ],
+  [
+    "design-tokens-strategy",
+    "4-tier design-token architecture: naming, mode design, tier reference rules. Load before creating or restructuring variables.",
+    design_tokens_strategy_default
+  ],
+  [
+    "component-architecture-strategy",
+    "Component conventions: token-first properties, state handling, size variants, variant naming. Load before building components.",
+    component_architecture_strategy_default
+  ],
+  [
+    "design-audit-strategy",
+    "End-to-end design audit workflow: overview \u2192 tokens \u2192 per-aspect analysis \u2192 report.",
+    design_audit_strategy_default
+  ],
+  [
+    "token-audit",
+    "Token-compliance check: find raw values, tier violations, scope issues, unbound properties.",
+    token_audit_default
+  ],
+  [
+    "component-spec",
+    "Generate a structured component specification: properties, variants, token bindings, state matrix.",
+    component_spec_default
+  ],
+  [
+    "comment-driven-tasks",
+    "Async collaboration via Figma comments: poll unresolved threads, claim, execute, report back on-thread. Load when asked to 'handle the comments' or work comment-driven.",
+    comment_driven_tasks_default
+  ],
+  [
+    "design-system-first",
+    "Build UI from the file's own system: inventory \u2192 conventions \u2192 instantiate components \u2192 bind variables \u2192 verify. Load before building screens in any file that has a design system.",
+    design_system_first_default
+  ],
+  [
+    "janitorial-cleanup",
+    "Bulk cleanup recipes: content-based layer renaming, tokenizing hardcoded values, spacing normalization, detached-instance sweeps \u2014 with preview-first discipline.",
+    janitorial_cleanup_default
+  ]
+];
+function registerPrompts(server) {
+  for (const [name, description, text] of SKILLS) {
+    server.prompt(name, description, () => ({
+      messages: [
+        {
+          role: "user",
+          content: { type: "text", text }
+        }
+      ]
+    }));
+  }
+}
+
+export {
+  createServer,
+  FIGMA_COMMANDS,
+  RelayCore,
+  PITFALLS,
+  registerRoomTool,
+  registerEventsTool,
+  registerAllTools,
+  listToolCatalog,
+  registerPrompts
+};
+//# sourceMappingURL=chunk-EBP7POOP.js.map