figma-relai 0.1.0

package/dist/index.js

@@ -0,0 +1,3526 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function createServer() {
+  return new McpServer(
+    {
+      name: "Relai",
+      version: "0.1.0"
+    },
+    {
+      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
+`
+    }
+  );
+}
+
+// src/connection.ts
+import WebSocket from "ws";
+import { v4 as uuidv4 } from "uuid";
+
+// src/logger.ts
+var logger = {
+  info: (message) => process.stderr.write(`[INFO] ${message}
+`),
+  debug: (message) => process.stderr.write(`[DEBUG] ${message}
+`),
+  warn: (message) => process.stderr.write(`[WARN] ${message}
+`),
+  error: (message) => process.stderr.write(`[ERROR] ${message}
+`)
+};
+
+// src/request-tracker.ts
+var RequestTracker = class {
+  pending = /* @__PURE__ */ new Map();
+  // Register a new pending request with timeout
+  add(id, resolve, reject, timeoutMs = 3e4) {
+    const timeout = setTimeout(() => {
+      if (this.pending.has(id)) {
+        this.pending.delete(id);
+        logger.error(`Request ${id} timed out after ${timeoutMs / 1e3}s`);
+        reject(new Error("Request to Figma timed out"));
+      }
+    }, timeoutMs);
+    this.pending.set(id, {
+      resolve,
+      reject,
+      timeout,
+      lastActivity: Date.now()
+    });
+  }
+  // Resolve a request with result
+  resolve(id, result) {
+    const request = this.pending.get(id);
+    if (!request) return false;
+    clearTimeout(request.timeout);
+    request.resolve(result);
+    this.pending.delete(id);
+    return true;
+  }
+  // Reject a request with error
+  reject(id, error) {
+    const request = this.pending.get(id);
+    if (!request) return false;
+    clearTimeout(request.timeout);
+    request.reject(error);
+    this.pending.delete(id);
+    return true;
+  }
+  // Reset timeout on progress update to prevent timeout during long operations
+  resetTimeout(id, extendedTimeoutMs = 6e4) {
+    const request = this.pending.get(id);
+    if (!request) return;
+    request.lastActivity = Date.now();
+    clearTimeout(request.timeout);
+    request.timeout = setTimeout(() => {
+      if (this.pending.has(id)) {
+        this.pending.delete(id);
+        logger.error(`Request ${id} timed out after extended inactivity`);
+        request.reject(new Error("Request to Figma timed out"));
+      }
+    }, extendedTimeoutMs);
+  }
+  // Check if a request is pending
+  has(id) {
+    return this.pending.has(id);
+  }
+  // Reject all pending requests (e.g., on connection close)
+  rejectAll(reason) {
+    for (const [id, request] of this.pending.entries()) {
+      clearTimeout(request.timeout);
+      request.reject(new Error(reason));
+    }
+    this.pending.clear();
+  }
+  get size() {
+    return this.pending.size;
+  }
+};
+
+// src/connection.ts
+function formatFigmaError(e) {
+  if (typeof e === "string") return e;
+  const { message, command, nodeId, nodeType } = e ?? {};
+  const prefix = command ? `[${command}] ` : "";
+  const suffix = nodeId ? ` (node ${nodeId}${nodeType ? `, type ${nodeType}` : ""})` : "";
+  return `${prefix}${message ?? JSON.stringify(e)}${suffix}`;
+}
+function routeResponse(response, tracker) {
+  if (!response?.id || !tracker.has(response.id)) return;
+  if (response.error !== void 0) {
+    tracker.reject(response.id, new Error(formatFigmaError(response.error)));
+  } else if ("result" in response) {
+    tracker.resolve(response.id, response.result);
+  }
+}
+var FigmaConnection = class {
+  ws = null;
+  currentRoom = null;
+  tracker = new RequestTracker();
+  wsUrl;
+  reconnectTimer = null;
+  shouldReconnect = false;
+  connectPromise = null;
+  commandHandler = null;
+  options;
+  relayVerified = false;
+  // null = unknown (no presence message yet); false = room has no plugin
+  pluginPresent = null;
+  // Designer activity piggybacked on plugin responses (selection changes etc.)
+  eventQueue = [];
+  constructor(serverUrl2 = "localhost", port2 = 9055, options = {}) {
+    const protocol = serverUrl2 === "localhost" ? "ws" : "wss";
+    this.wsUrl = serverUrl2 === "localhost" ? `${protocol}://${serverUrl2}:${port2}` : `${protocol}://${serverUrl2}`;
+    this.options = options;
+  }
+  // Connect to WebSocket relay server
+  connect() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      logger.info("Already connected to relay");
+      return Promise.resolve();
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    logger.info(`Connecting to relay at ${this.wsUrl}...`);
+    this.connectPromise = new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.wsUrl);
+      this.ws = ws;
+      const cleanup = () => {
+        this.connectPromise = null;
+      };
+      ws.on("open", () => {
+        logger.info("Connected to relay server");
+        this.shouldReconnect = true;
+        cleanup();
+        resolve();
+        this.relayVerified = false;
+        try {
+          ws.send(JSON.stringify({ type: "hello" }));
+        } catch {
+        }
+        setTimeout(() => {
+          if (!this.relayVerified && this.ws === ws) {
+            logger.warn(
+              "Connected endpoint did not identify as a figma-relai relay \u2014 is another app using the port?"
+            );
+          }
+        }, 1500);
+        if (this.currentRoom) {
+          const room = this.currentRoom;
+          this.sendCommand("join", { room }).then(
+            () => logger.info(`Rejoined room: ${room}`),
+            (err) => logger.warn(
+              `Failed to rejoin room ${room}: ${err instanceof Error ? err.message : String(err)}`
+            )
+          );
+        }
+      });
+      ws.on("message", (data) => {
+        try {
+          const json = JSON.parse(data.toString());
+          if (json.type === "hello" && json.server === "figma-relai") {
+            this.relayVerified = true;
+            logger.debug(`Relay verified (version ${json.version})`);
+            return;
+          }
+          if (json.type === "presence") {
+            if (json.room === this.currentRoom && Array.isArray(json.peers)) {
+              this.pluginPresent = json.peers.some(
+                (p) => p.role === "plugin"
+              );
+            }
+            return;
+          }
+          if (json.type === "list_rooms_result" && json.id) {
+            this.tracker.resolve(json.id, json.rooms ?? []);
+            return;
+          }
+          if (json.type === "broadcast" && json.message?.command) {
+            this.commandHandler?.(json.message.command, json.message.params);
+            return;
+          }
+          if (json.type === "progress_update") {
+            const progressData = json.message?.data;
+            const requestId = json.id || "";
+            if (requestId && this.tracker.has(requestId)) {
+              this.tracker.resetTimeout(requestId);
+              logger.info(
+                `Progress: ${progressData.commandType} ${progressData.progress}% - ${progressData.message}`
+              );
+            }
+            return;
+          }
+          if (Array.isArray(json.message?.events)) {
+            this.eventQueue.push(...json.message.events);
+            if (this.eventQueue.length > 50) {
+              this.eventQueue = this.eventQueue.slice(-50);
+            }
+          }
+          routeResponse(json.message, this.tracker);
+        } catch (error) {
+          logger.error(
+            `Error parsing message: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      });
+      ws.on("error", (error) => {
+        logger.error(`WebSocket error: ${error.message}`);
+        cleanup();
+        reject(error);
+      });
+      ws.on("close", () => {
+        logger.info("Disconnected from relay");
+        this.ws = null;
+        this.tracker.rejectAll("Connection closed");
+        cleanup();
+        if (this.shouldReconnect) {
+          this.reconnectTimer = setTimeout(async () => {
+            try {
+              await this.options.beforeReconnect?.();
+            } catch {
+            }
+            this.connect().catch(() => {
+            });
+          }, 2e3);
+        }
+      });
+    });
+    return this.connectPromise;
+  }
+  // Disconnect and stop reconnection
+  disconnect() {
+    this.shouldReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  // Join a room for communication
+  async joinRoom(roomName) {
+    await this.sendCommand("join", { room: roomName });
+    this.currentRoom = roomName;
+    this.pluginPresent = null;
+    this.options.onRoomChanged?.(roomName);
+    logger.info(`Joined room: ${roomName}`);
+  }
+  // Ask the relay which rooms exist and who is in them
+  listRooms() {
+    return new Promise((resolve, reject) => {
+      const id = uuidv4();
+      this.tracker.add(id, resolve, reject, 5e3);
+      this.ws.send(JSON.stringify({ type: "list_rooms", id }));
+    });
+  }
+  // Auto-pair with the plugin so join_room is only needed for disambiguation:
+  // prefer the persisted room if its plugin is present, otherwise join the
+  // single plugin room, otherwise explain exactly what to do.
+  async ensureRoom() {
+    if (this.currentRoom) return;
+    const rooms = await this.listRooms();
+    const withPlugin = rooms.filter((r) => r.hasPlugin);
+    const saved = this.options.initialRoom;
+    if (saved && withPlugin.some((r) => r.room === saved)) {
+      return this.joinRoom(saved);
+    }
+    if (withPlugin.length === 1) {
+      return this.joinRoom(withPlugin[0].room);
+    }
+    if (withPlugin.length === 0) {
+      throw new Error(
+        "No Figma plugin is connected. Open the Relai plugin in Figma (it connects automatically), then try again."
+      );
+    }
+    throw new Error(
+      `Multiple Figma plugins are connected (rooms: ${withPlugin.map((r) => r.room).join(", ")}). Call join_room with the room shown in the plugin you want to control.`
+    );
+  }
+  // Send a command to Figma plugin via the relay
+  async sendCommand(command, params = {}, timeoutMs = 3e4) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      try {
+        await this.connect();
+      } catch {
+        throw new Error(
+          "Not connected to the relay. The MCP server hosts it automatically \u2014 if this persists, another app may be occupying the port."
+        );
+      }
+    }
+    if (command !== "join") {
+      await this.ensureRoom();
+      if (this.pluginPresent === false) {
+        throw new Error(
+          "The Figma plugin is not open. Open the Relai plugin in Figma \u2014 it will reconnect to the same room automatically."
+        );
+      }
+    }
+    const result = await new Promise((resolve, reject) => {
+      const id = uuidv4();
+      const request = {
+        id,
+        type: command === "join" ? "join" : "message",
+        room: command === "join" ? params.room : this.currentRoom,
+        ...command === "join" ? { role: "agent", meta: { client: "figma-relai-mcp" } } : {},
+        message: {
+          id,
+          command,
+          params: {
+            ...params,
+            commandId: id
+          }
+        }
+      };
+      this.tracker.add(id, resolve, reject, timeoutMs);
+      logger.info(`Sending command: ${command}`);
+      logger.debug(`Request: ${JSON.stringify(request)}`);
+      this.ws.send(JSON.stringify(request));
+    });
+    if (this.eventQueue.length > 0 && result !== null && typeof result === "object" && !Array.isArray(result)) {
+      return { ...result, designer_events: this.consumeEvents() };
+    }
+    return result;
+  }
+  // Drain buffered designer-activity events
+  consumeEvents() {
+    const drained = this.eventQueue;
+    this.eventQueue = [];
+    return drained;
+  }
+  // Set handler for incoming commands from other room members (e.g. plugin UI)
+  setCommandHandler(handler) {
+    this.commandHandler = handler;
+  }
+  get isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  get room() {
+    return this.currentRoom;
+  }
+};
+
+// src/tools/index.ts
+import { z as z21 } from "zod";
+
+// src/tools/core/create.ts
+var create_exports = {};
+__export(create_exports, {
+  register: () => register
+});
+import { z as z2 } from "zod";
+
+// ../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;
+          rooms.push({
+            room,
+            hasPlugin: [...peers.values()].some((p) => p.role === "plugin"),
+            agentCount: [...peers.values()].filter((p) => p.role === "agent").length
+          });
+        }
+        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/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(),
+  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.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.",
+    {
+      nodeIds: z3.array(z3.string()).min(1).describe("Node IDs to update"),
+      properties: propertiesSchema.describe("Properties to apply to every listed node")
+    },
+    { idempotentHint: true },
+    async ({ nodeIds, properties }) => {
+      try {
+        const commands = nodeIds.flatMap(
+          (nodeId) => mapPropertiesToCommands(nodeId, properties)
+        );
+        if (commands.length === 0) return textResult("No properties given \u2014 nothing to do.");
+        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), detach.",
+    {
+      action: z6.enum([
+        "list",
+        "create",
+        "create_set",
+        "instantiate",
+        "get_props",
+        "set_props",
+        "get_overrides",
+        "set_overrides",
+        "detach"
+      ]),
+      nodeId: z6.string().optional().describe("Target node (create/get_props/set_props/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 (args2) => {
+      try {
+        let result;
+        switch (args2.action) {
+          case "list":
+            result = await sendCommand("get_local_components", {}, 6e4);
+            break;
+          case "create":
+            result = await sendCommand("create_component_from_node", { nodeId: args2.nodeId });
+            break;
+          case "create_set":
+            result = await sendCommand("create_component_set", { componentIds: args2.componentIds });
+            break;
+          case "instantiate":
+            result = await sendCommand("create_component_instance", {
+              componentKey: args2.componentKey,
+              x: args2.x,
+              y: args2.y
+            });
+            break;
+          case "get_props":
+            result = await sendCommand("get_component_properties", { nodeId: args2.nodeId });
+            break;
+          case "set_props":
+            result = await sendCommand("set_component_properties", {
+              nodeId: args2.nodeId,
+              properties: args2.properties
+            });
+            break;
+          case "get_overrides":
+            result = await sendCommand("get_instance_overrides", {
+              instanceNodeId: args2.instanceNodeId ?? args2.nodeId
+            });
+            break;
+          case "set_overrides":
+            result = await sendCommand("set_instance_overrides", {
+              sourceInstanceId: args2.sourceInstanceId,
+              targetNodeIds: args2.targetNodeIds
+            });
+            break;
+          case "detach":
+            result = await sendCommand("detach_instance", { nodeId: args2.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"]]
+};
+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. 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()
+    },
+    async (args2) => {
+      try {
+        const [command, fields] = ACTIONS[args2.action];
+        const params = Object.fromEntries(
+          fields.map((f) => [f, args2[f]]).filter(([, v]) => v !== void 0)
+        );
+        const result = await sendCommand(command, params);
+        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 (args2) => {
+      try {
+        let result;
+        switch (args2.action) {
+          case "list":
+            result = await sendCommand("get_styles", {});
+            break;
+          case "create_paint":
+            result = await sendCommand("create_paint_style", {
+              name: args2.name,
+              color: args2.color,
+              gradientType: args2.gradientType,
+              gradientStops: args2.gradientStops
+            });
+            break;
+          case "create_text":
+            result = await sendCommand("create_text_style", {
+              name: args2.name,
+              fontFamily: args2.fontFamily,
+              fontSize: args2.fontSize,
+              fontWeight: args2.fontWeight,
+              lineHeight: args2.lineHeight,
+              letterSpacing: args2.letterSpacing
+            });
+            break;
+          case "create_effect":
+            result = await sendCommand("create_effect_style", {
+              name: args2.name,
+              effectType: args2.effectType,
+              color: args2.color,
+              offsetX: args2.offsetX,
+              offsetY: args2.offsetY,
+              radius: args2.radius,
+              spread: args2.spread
+            });
+            break;
+          case "create_grid":
+            result = await sendCommand("create_grid_style", { name: args2.name, grids: args2.grids });
+            break;
+          case "update":
+            result = await sendCommand("update_style", {
+              styleId: args2.styleId,
+              name: args2.name,
+              properties: args2.properties
+            });
+            break;
+          case "delete":
+            result = await sendCommand("delete_style", { styleId: args2.styleId });
+            break;
+          case "apply":
+            result = await sendCommand("apply_style", {
+              nodeId: args2.nodeId,
+              styleId: args2.styleId,
+              styleType: args2.styleType
+            });
+            break;
+          case "reorder":
+            result = await sendCommand("reorder_style", {
+              styleId: args2.styleId,
+              afterStyleId: args2.afterStyleId,
+              styleType: args2.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` in scope; its return value is serialized back (node objects become summaries). console.log output is captured into `logs`. Work incrementally: small scripts, verify with screenshot between steps. Remember dynamic-page rules (use figma.getNodeByIdAsync, await figma.loadFontAsync before text edits). 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")
+    },
+    async ({ code, description }) => {
+      try {
+        const result = await sendCommand("execute_code", { code, description }, 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'), add (optionally pinned to a node), reply, delete. 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()
+    },
+    async ({ action, fileUrl, message, commentId, nodeId, x, y }) => {
+      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`);
+            const comments = (data.comments ?? []).slice(0, 100).map(compactComment);
+            return jsonResult({ count: comments.length, comments });
+          }
+          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/batch.ts
+var batch_exports = {};
+__export(batch_exports, {
+  register: () => register16
+});
+import { z as z17 } from "zod";
+function textResult2(text) {
+  return { content: [{ type: "text", text }] };
+}
+function register16(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.",
+    {
+      commands: z17.array(
+        z17.object({
+          command: z17.string().describe("Command name"),
+          params: z17.record(z17.string(), z17.unknown()).optional().describe("Command parameters")
+        })
+      ).describe("Array of commands to execute sequentially")
+    },
+    async ({ commands }) => {
+      try {
+        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: () => register17
+});
+import { z as z18 } 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 register17(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] = await Promise.all([
+          sendCommand("get_document_info"),
+          sendCommand("get_variable_collections"),
+          sendCommand("get_styles")
+        ]);
+        const componentCount = docInfo.componentCount ?? 0;
+        const stylesByType = { paint: 0, text: 0, effect: 0, grid: 0 };
+        if (Array.isArray(styles)) {
+          for (const s of styles) {
+            const t = (s.type || "").toLowerCase();
+            if (t === "paint") stylesByType.paint++;
+            else if (t === "text") stylesByType.text++;
+            else if (t === "effect") stylesByType.effect++;
+            else if (t === "grid") stylesByType.grid++;
+          }
+        }
+        const data = {
+          name: docInfo.name,
+          currentPage: docInfo.currentPage,
+          pages: docInfo.pages || [],
+          counts: {
+            components: componentCount,
+            styles: Array.isArray(styles) ? styles.length : 0,
+            variableCollections: Array.isArray(collections) ? collections.length : 0
+          }
+        };
+        return standardResult({
+          summary: `"${data.name}" \u2014 ${data.pages.length} pages, ${data.counts.components} components, ${data.counts.styles} styles, ${data.counts.variableCollections} variable collections`,
+          data,
+          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: z18.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: z18.string().optional().describe("Name substring to search for"),
+      types: z18.array(z18.string()).optional().describe("Node types to filter: FRAME, TEXT, COMPONENT, INSTANCE, RECTANGLE, etc."),
+      parentId: z18.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 stylesByType = { 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 stylesByType) stylesByType[t]++;
+          }
+        }
+        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: z18.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: () => register18
+});
+import { z as z19 } 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 register18(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), or overall (runs all four and returns a weighted 0-100 health score with per-category breakdown \u2014 good for audits and reports). Defaults to the current selection.",
+    {
+      aspect: z19.enum(["color", "layout", "components", "accessibility", "overall"]),
+      nodeId: z19.string().optional().describe("Root node to analyze (default: current selection)")
+    },
+    { readOnlyHint: true },
+    async ({ aspect, nodeId }) => {
+      if (aspect === "overall") {
+        return runOverallAudit(aspectHandlers, nodeId);
+      }
+      const handler = aspectHandlers.get(ASPECT_TOOL[aspect]);
+      if (!handler) throw new Error(`Unknown aspect: ${aspect}`);
+      return handler({ nodeId });
+    }
+  );
+}
+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: z19.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 };
+        for (const id of targetIds) {
+          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
+        };
+        const warnings = unboundColors.length > 0 ? [{ category: "tokens", message: `${unboundColors.length} color(s) not bound to design tokens` }] : [];
+        return standardResult({
+          summary: `Color audit: ${unboundColors.length} unbound color(s) found. Token coverage: ${Math.round(data.tokenCoverage * 100)}%`,
+          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: z19.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: z19.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: z19.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: z19.string().describe("First node ID (or the checkpoint target)"),
+      nodeIdB: z19.string().optional().describe("Second node ID (omit when using checkpoint)"),
+      checkpoint: z19.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: () => register19
+});
+import { z as z20 } from "zod";
+function register19(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: z20.string().describe("Node ID to verify"),
+      expected: z20.record(z20.string(), z20.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: z20.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
+          });
+        }
+        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: z20.string().describe("Node to verify"),
+      expected: z20.record(z20.string(), z20.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"],
+  [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: z21.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, getSessionLog2) {
+  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: z21.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 = getSessionLog2();
+      }
+      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;
+}
+
+// src/embedded-relay.ts
+import { createServer as createServer2 } from "http";
+import { WebSocketServer } from "ws";
+function startEmbeddedRelay(port2, version) {
+  return new Promise((resolve) => {
+    const httpServer = createServer2();
+    httpServer.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve(null);
+      } else {
+        logger.warn(`Embedded relay failed to start: ${err.message}`);
+        resolve(null);
+      }
+    });
+    httpServer.listen(port2, "127.0.0.1", () => {
+      const core = new RelayCore({
+        version,
+        log: (msg) => logger.debug(`[relay] ${msg}`)
+      });
+      const wss = new WebSocketServer({ server: httpServer });
+      wss.on("connection", (ws) => {
+        core.handleOpen(ws);
+        ws.on("message", (data) => core.handleMessage(ws, data.toString()));
+        ws.on("close", () => core.handleClose(ws));
+        ws.on("error", () => {
+        });
+      });
+      core.startStaleCleanup();
+      logger.info(`Hosting embedded relay on 127.0.0.1:${port2}`);
+      resolve({
+        close() {
+          core.stop();
+          wss.close();
+          httpServer.close();
+        }
+      });
+    });
+  });
+}
+
+// src/state.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function stateDir() {
+  return process.env.FIGMA_RELAI_STATE_DIR ?? join(homedir(), ".figma-relai");
+}
+function statePath() {
+  return join(stateDir(), "state.json");
+}
+function loadState() {
+  try {
+    return JSON.parse(readFileSync(statePath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveState(patch) {
+  try {
+    mkdirSync(stateDir(), { recursive: true });
+    const next = { ...loadState(), ...patch, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    writeFileSync(statePath(), JSON.stringify(next, null, 2) + "\n");
+  } catch {
+  }
+}
+
+// ../../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## Pitfalls that throw\n\n- `resize(w, h)` with `w <= 0 || h <= 0`; resizing nodes without `resize` (e.g. some text auto-resize modes \u2014 set `textAutoResize` first).\n- Setting layout-child props (`layoutSizing*`, `layoutAlign`) when the **parent** has `layoutMode: "NONE"`.\n- `layoutWrap = "WRAP"` on VERTICAL; `counterAxisAlignItems = "BASELINE"` on VERTICAL.\n- Editing `characters` without loading fonts \u2192 "unloaded font".\n- Per-corner radius (`topLeftRadius` \u2026) on nodes without RectangleCornerMixin (polygons, stars, lines).\n- Touching `node.removed === true` nodes; writing to `locked` nodes is allowed by API but surprises designers \u2014 check first.\n- `instance.children` mutations \u2014 detach first or edit the main component.\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';
+
+// ../../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";
+
+// ../../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";
+
+// ../../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";
+
+// ../../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";
+
+// ../../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";
+
+// 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
+  ]
+];
+function registerPrompts(server) {
+  for (const [name, description, text] of SKILLS) {
+    server.prompt(name, description, () => ({
+      messages: [
+        {
+          role: "user",
+          content: { type: "text", text }
+        }
+      ]
+    }));
+  }
+}
+
+// src/session-log.ts
+var MAX_ENTRIES = 200;
+var entries = [];
+function recordCommand(entry) {
+  entries.push(entry);
+  if (entries.length > MAX_ENTRIES) entries = entries.slice(-MAX_ENTRIES);
+}
+function getSessionLog() {
+  return [...entries];
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+var args = process.argv.slice(2);
+var serverArg = args.find((arg) => arg.startsWith("--server="));
+var serverUrl = serverArg ? serverArg.split("=")[1] : "localhost";
+var portArg = args.find((arg) => arg.startsWith("--port="));
+var port = portArg ? parseInt(portArg.split("=")[1]) : 9055;
+var roomArg = args.find((arg) => arg.startsWith("--room="));
+if (args.includes("--list-tools")) {
+  console.log(JSON.stringify(listToolCatalog(), null, 2));
+  process.exit(0);
+}
+async function main() {
+  const server = createServer();
+  let relay = null;
+  if (serverUrl === "localhost") {
+    relay = await startEmbeddedRelay(port, VERSION);
+    if (!relay) {
+      logger.info(`Port ${port} in use \u2014 connecting to the existing relay`);
+    }
+  }
+  const initialRoom = roomArg?.split("=")[1] ?? process.env.FIGMA_RELAI_ROOM ?? loadState().room ?? null;
+  const connection = new FigmaConnection(serverUrl, port, {
+    initialRoom,
+    onRoomChanged: (room) => saveState({ room }),
+    beforeReconnect: async () => {
+      if (serverUrl === "localhost" && !relay) {
+        relay = await startEmbeddedRelay(port, VERSION);
+        if (relay) logger.info("Took over relay hosting");
+      }
+    }
+  });
+  registerRoomTool(server, (room) => connection.joinRoom(room));
+  registerEventsTool(server, () => connection.consumeEvents(), getSessionLog);
+  registerPrompts(server);
+  registerAllTools(server, async (command, params, timeoutMs) => {
+    const t0 = Date.now();
+    const nodeId = typeof params?.nodeId === "string" ? params.nodeId : void 0;
+    try {
+      const result = await connection.sendCommand(command, params, timeoutMs);
+      recordCommand({ ts: t0, command, nodeId, ok: true, ms: Date.now() - t0 });
+      return result;
+    } catch (error) {
+      recordCommand({
+        ts: t0,
+        command,
+        nodeId,
+        ok: false,
+        ms: Date.now() - t0,
+        error: error instanceof Error ? error.message.slice(0, 200) : String(error)
+      });
+      throw error;
+    }
+  });
+  try {
+    await connection.connect();
+    logger.info("Connected to relay successfully");
+  } catch (error) {
+    logger.warn(
+      `Could not connect initially: ${error instanceof Error ? error.message : String(error)}`
+    );
+    logger.warn("Will attempt to connect when the first command is sent");
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  logger.info("Relai MCP server running on stdio");
+}
+main().catch((error) => {
+  logger.error(
+    `Fatal error: ${error instanceof Error ? error.message : String(error)}`
+  );
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map