figma-relai 0.1.4 → 0.2.1

package/dist/index.js

@@ -1,79 +1,22 @@
 #!/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 });
-};
+import {
+  RelayCore,
+  createServer,
+  listToolCatalog,
+  registerAllTools,
+  registerEventsTool,
+  registerPrompts,
+  registerRoomTool
+} from "./chunk-EBP7POOP.js";
+import {
+  loadState,
+  saveState
+} from "./chunk-XBWGSCRZ.js";
+import "./chunk-2H7UOFLK.js";
 
 // 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.4"
-    },
-    {
-      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";
@@ -432,3047 +375,88 @@ var FigmaConnection = class {
   }
 };
 
-// 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;
-          const pluginPeer = [...peers.values()].find((p) => p.role === "plugin");
-          const fileName = typeof pluginPeer?.meta?.fileName === "string" ? pluginPeer.meta.fileName : void 0;
-          rooms.push({
-            room,
-            hasPlugin: pluginPeer !== void 0,
-            agentCount: [...peers.values()].filter((p) => p.role === "agent").length,
-            ...fileName ? { fileName } : {}
-          });
-        }
-        this.send(ws, { type: "list_rooms_result", id: data.id, rooms });
-        return;
+// 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);
       }
-      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
+    });
+    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", () => {
         });
-        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);
+      });
+      core.startStaleCleanup();
+      logger.info(`Hosting embedded relay on 127.0.0.1:${port2}`);
+      resolve({
+        close() {
+          core.stop();
+          wss.close();
+          httpServer.close();
         }
-      }
-    }, 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/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);
 }
-
-// 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);
-      }
-    }
-  );
+function getSessionLog() {
+  return [...entries];
 }
 
-// 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/index.ts
+var VERSION = "0.2.1";
+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);
 }
-
-// src/tools/core/read.ts
-var read_exports = {};
-__export(read_exports, {
-  register: () => register13
-});
-import { z as z14 } from "zod";
-function register13(server, sendCommand) {
-  server.tool(
-    "get_node_data",
-    "Raw node data at a chosen detail level: summary (shallow), tree (sparse structure for orientation), full (deeper serialization), css (CSS representation), variables (bound variable ids). For human-oriented summaries prefer get_node_details / get_selection_context.",
-    {
-      nodeIds: z14.array(z14.string()).min(1).describe("One or more node ids"),
-      detail: z14.enum(["summary", "tree", "full", "css", "variables"]).optional().describe("Default summary"),
-      depth: z14.number().int().min(0).optional().describe("Override serialization depth"),
-      maxNodes: z14.number().int().positive().optional().describe("Override node budget")
-    },
-    { readOnlyHint: true },
-    async ({ nodeIds, detail = "summary", depth, maxNodes }) => {
-      try {
-        if (detail === "css" || detail === "variables") {
-          const command = detail === "css" ? "get_css" : "get_bound_variables";
-          const results = [];
-          for (const nodeId of nodeIds) {
-            results.push({ nodeId, data: await sendCommand(command, { nodeId }) });
-          }
-          return jsonResult(nodeIds.length === 1 ? results[0].data : results);
-        }
-        if (detail === "tree") {
-          const results = [];
-          for (const nodeId of nodeIds) {
-            results.push(await sendCommand("get_node_tree", { nodeId, depth, maxNodes }));
-          }
-          return jsonResult(nodeIds.length === 1 ? results[0] : results);
-        }
-        if (nodeIds.length > 1) {
-          const result2 = await sendCommand("get_nodes_info", { nodeIds });
-          return jsonResult(result2);
-        }
-        const result = await sendCommand("get_node_info", {
-          nodeId: nodeIds[0],
-          depth: depth ?? (detail === "full" ? 4 : 1),
-          maxNodes
-        });
-        return jsonResult(result);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-}
-
-// src/tools/core/execute.ts
-var execute_exports = {};
-__export(execute_exports, {
-  register: () => register14
-});
-import { z as z15 } from "zod";
-function register14(server, sendCommand) {
-  server.tool(
-    "execute_figma",
-    "Run JavaScript against the Figma Plugin API inside the plugin sandbox \u2014 the escape hatch for anything the other tools don't cover. The code runs in an async function with `figma` AND `relai` in scope. relai helpers avoid the classic pitfalls: relai.text(parent, chars, {font,size,color}) loads fonts first; relai.autoLayout(direction, props) makes a hugging auto-layout frame; relai.set(node, props) applies layoutMode first and routes width/height through resize; relai.hug(node); relai.focusRing(node); await relai.page(p => ...) finds pages by content, not name; relai.query('FRAME[name^=Card] > TEXT') is a CSS-like search (types, name matchers, descendant/child, comma); relai.placeholder(node) shows a construction veil \u2014 remove with (node, false) when done. Errors carry a Hint with the fix; scripts are NOT atomic \u2014 on error, partial changes persist, so keep scripts small and idempotent. Nodes created via relai plus any node ids you RETURN are linted for silent mistakes (e.g. spread shadows without clipsContent) and come back as `warnings`. Return ALL created/mutated node ids. Work incrementally; verify with screenshot. The designer can disable this tool via the plugin's 'Allow code execution' toggle.",
-    {
-      code: z15.string().describe("JavaScript source. May use await. Return a JSON-serializable value."),
-      description: z15.string().optional().describe("One line shown in the plugin's activity feed describing what this does"),
-      timeoutMs: z15.number().int().min(1e3).max(3e5).optional().describe("Execution timeout in ms (default 60000) \u2014 raise for scripts creating hundreds of nodes")
-    },
-    async ({ code, description, timeoutMs }) => {
-      try {
-        const result = await sendCommand("execute_code", { code, description }, timeoutMs ?? 6e4);
-        return jsonResult(result);
-      } catch (error) {
-        return errorResult(error);
-      }
-    }
-  );
-}
-
-// src/tools/core/comments.ts
-var comments_exports = {};
-__export(comments_exports, {
-  parseFileKey: () => parseFileKey,
-  register: () => register15
-});
-import { z as z16 } from "zod";
-var API = "https://api.figma.com/v1";
-function parseFileKey(input) {
-  const url = input.match(/figma\.com\/(?:file|design)\/([A-Za-z0-9]+)/);
-  if (url) return url[1];
-  if (/^[A-Za-z0-9]{15,}$/.test(input)) return input;
-  return null;
-}
-function compactComment(c) {
-  return {
-    id: c.id,
-    message: c.message,
-    author: c.user?.handle,
-    created_at: c.created_at,
-    ...c.resolved_at ? { resolved: true } : {},
-    ...c.parent_id ? { replyTo: c.parent_id } : {},
-    ...c.client_meta?.node_id ? { nodeId: c.client_meta.node_id } : {}
-  };
-}
-function register15(server, sendCommand) {
-  server.tool(
-    "manage_comments",
-    "Read and write comments on the Figma file: list (with node anchors \u2014 great for 'apply the feedback in the comments'), 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}`;
+var subcommand = args.find((a) => !a.startsWith("--"));
+if (subcommand === "manifest" || subcommand === "docs" || subcommand === "doctor") {
+  const { buildManifest } = await import("./manifest-CFCCUJEV.js");
+  if (subcommand === "doctor") {
+    const { runDoctor, renderDoctor } = await import("./doctor-ZN2PKAPH.js");
+    const results = await runDoctor();
+    console.log(args.includes("--json") ? JSON.stringify(results, null, 2) : renderDoctor(results));
+    process.exit(results.some((r) => r.status === "warn") ? 1 : 0);
+  }
+  const manifest = await buildManifest(VERSION);
+  if (subcommand === "manifest") {
+    console.log(JSON.stringify(manifest, null, 2));
   } 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## `relai.*` helpers \u2014 the shortest path is the correct one\n\nAlongside `figma`, scripts get a `relai` object whose helpers are immune to the pitfalls below. Prefer them:\n\n```js\nawait relai.text(parent, "Hello", { font: {family:"IBM Plex Mono", style:"Regular"}, size: 14, color: {r:0,g:0,b:0} });\n                                          // loads the font BEFORE writing characters\nconst card = relai.autoLayout("VERTICAL", { name: "Card", itemSpacing: 8 });\n                                          // auto-layout frame, both axes hugging\nrelai.set(node, { layoutMode: "HORIZONTAL", width: 320, opacity: 0.9 });\n                                          // layoutMode applied first; width/height via resize()\nrelai.hug(node);                          // HUG that sticks \u2014 call after appending children\nrelai.focusRing(button);                  // clipsContent + double spread shadows that render\nconst page = await relai.page(p => p.children.some(c => c.name === "Button"));\n                                          // find pages by CONTENT \u2014 names get renamed\nconst titles = relai.query(\'FRAME[name^=Card] > TEXT\');\n                                          // CSS-like search on the current page; relai.query(node, sel) scopes to a subtree.\n                                          // Supported: TYPE, *, [name=] [name*=] [name^=] [name$=], descendant, >, comma.\n                                          // NOT supported: pseudo-classes, dot-paths, sibling combinators \u2014 use findAll.\nrelai.placeholder(section);               // construction veil so the designer sees work-in-progress\nrelai.placeholder(section, false);        // ALWAYS remove when the section is done\n```\n\nTwo important facts: **scripts are NOT atomic** \u2014 on error, changes made before the throw persist, so keep scripts small and clean up after failures; and results may carry a `warnings` array for silent mistakes the lint catches on relai-created nodes and any node ids you return (e.g. spread shadows on a non-clipping frame). Convention: **return every created/mutated node id** (`return { createdNodeIds: [...] }`) \u2014 it powers both follow-up calls and the lint.\n\n## Pitfalls that throw (or silently do the wrong thing)\n\nWhen one of these throws inside `execute_figma`, the error already carries the remedy as a `Hint:` \u2014 this list is generated from the same registry (`packages/shared/src/pitfalls.ts`).\n\n<!-- PITFALLS:START -->\n- **Editing text without loading its font throws** (`unloaded font`). `await figma.loadFontAsync(textNode.fontName)` first; new TextNodes default to Inter Regular; when `fontName === figma.mixed`, load every font from `getRangeAllFontNames()`.\n- **`getNodeById` throws in dynamic-page mode** \u2014 always `await figma.getNodeByIdAsync(id)`.\n- **Traversing a non-current page throws until you `await page.loadAsync()`** \u2014 `figma.currentPage` is always loaded, other pages are not.\n- **`layoutSizingHorizontal/Vertical` throw without auto-layout** \u2014 FILL requires the parent to have a `layoutMode`, HUG requires it on the node itself.\n- **`createPage()` throws on the free plan once a file has 3 pages** \u2014 reuse an existing page instead.\n- **`width`/`height` are read-only** \u2014 use `node.resize(w, h)`.\n- **`figma.mixed` is a Symbol** returned by `fontSize`, `cornerRadius`, `fills` etc. when values differ across ranges/children \u2014 check `=== figma.mixed` before use; never JSON-serialize it.\n- **Exact-name lookups are fragile** \u2014 designers rename pages and layers freely; locate nodes by type/content instead of `name ===`.\n- **Stale node ids throw `does not exist`** \u2014 nodes get deleted while you work; re-read before editing and check `node.removed`.\n- **Nodes are non-extensible** \u2014 `node.myCustomProp = x` throws `object is not extensible`; use `setPluginData` or return the data instead.\n- **Shadow `spread` renders only on shapes or frames with `clipsContent: true`** \u2014 a focus ring built from spread shadows is invisible on a non-clipping frame/component.\n- **`resize()` on an auto-layout frame silently pins that axis to FIXED**, overriding `primaryAxisSizingMode: "AUTO"`. Append children first, then set `layoutSizingHorizontal = "HUG"`; use `resize` only for the fixed cross-axis.\n- **Per-corner radius** (`topLeftRadius` \u2026) only exists on RectangleCornerMixin nodes (rectangles, frames, components) \u2014 polygons, stars and lines throw.\n- **Instance children can\'t be added or removed** \u2014 detach first, or edit the main component.\n<!-- PITFALLS:END -->\n\nAlso: `resize(w, h)` throws on `w <= 0 || h <= 0`; `layoutWrap = "WRAP"` is HORIZONTAL-only, `counterAxisAlignItems = "BASELINE"` too; writing to `locked` nodes is allowed by the API but surprises designers \u2014 check first.\n\n## Return values\n\nReturn JSON-serializable data (the bridge summarizes nodes automatically and truncates >50k chars). Prefer returning `{ id, name, type }` summaries over whole nodes. `console.log` is captured and returned in `logs`.\n';
-
-// ../../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 }
-        }
-      ]
-    }));
+    const { renderToolDoc, renderToolIndex } = await import("./docs-S7VJ2PPR.js");
+    const toolName = args[args.indexOf("docs") + 1];
+    console.log(
+      toolName && !toolName.startsWith("--") ? renderToolDoc(manifest, toolName) : renderToolIndex(manifest)
+    );
   }
-}
-
-// 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.4";
-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() {