figma-rust-mcp 2.8.5 → 2.9.6

package/plugin/code.js

@@ -1,7 +1,7 @@
 // figma-mcp — Figma Plugin main thread v1.2.1
 // Handles both WRITE (draw UI) and READ (extract design) operations.
 // AUTO-GENERATED by scripts/build-plugin.js — edit plugin-src/*.js instead
-// Generated: 2026-08-26T04:26:26.667Z
+// Generated: 2026-08-27T07:20:35.052Z
 
 // ── plugin-src/utils.js ──
 // ─── UTILS ────────────────────────────────────────────────────────────────────
@@ -328,6 +328,13 @@ function nodeToInfo(node) {
   return info;
 }
 
+// Yield execution back to Figma main thread loop so UI never freezes/blocks
+function yieldToUI(delayMs) {
+  return new Promise(function(resolve) {
+    setTimeout(resolve, delayMs !== undefined ? delayMs : 0);
+  });
+}
+
 
 // ── plugin-src/svg-path-helpers.js ──
 // ─── SVG PATH NORMALIZATION ───────────────────────────────────────────────────
@@ -1238,7 +1245,7 @@ const handlers = {};
 
 handlers.status = async () => ({
   connected:   true,
-  version:     "2.8.3",
+  version:     "2.9.6",
   fileName:    figma.root.name,
   currentPage: figma.currentPage.name,
   pageCount:   figma.root.children.length,
@@ -2902,8 +2909,37 @@ handlers.screenshot = async function(params) {
     return Promise.reject(new Error("[v1.9.1-export] " + exportErr.message + " type=" + node.type + " id=" + node.id));
   }
 
+  var annotations = [];
+  if (params && (params.withAnnotations || params.annotated) && "children" in node && Array.isArray(node.children)) {
+    var annCount = 0;
+    for (var ci = 0; ci < node.children.length; ci++) {
+      var child = node.children[ci];
+      if (child.visible === false) continue;
+      annCount++;
+      annotations.push({
+        index: annCount,
+        id: child.id,
+        name: child.name,
+        type: child.type,
+        x: Math.round(child.x),
+        y: Math.round(child.y),
+        width: Math.round(child.width),
+        height: Math.round(child.height)
+      });
+      if (annCount >= 40) break;
+    }
+  }
+
   try {
-    return { dataUrl: "data:image/png;base64," + uint8ArrayToBase64(bytes), nodeId: node.id, width: node.width, height: node.height };
+    var resObj = {
+      dataUrl: "data:image/png;base64," + uint8ArrayToBase64(bytes),
+      nodeId: node.id,
+      nodeName: node.name,
+      width: node.width,
+      height: node.height
+    };
+    if (annotations.length) resObj.annotations = annotations;
+    return resObj;
   } catch(encodeErr) {
     return Promise.reject(new Error("[v1.9.1-encode] " + encodeErr.message));
   }
@@ -3006,64 +3042,106 @@ handlers.export_image = async function(params) {
   };
 };
 
-// index_scan — aggregate page nodes, styles, variables, and components in one call for pre-indexing (concurrently)
+// index_scan — aggregate page nodes, styles, variables, and components in one call for pre-indexing
 handlers.index_scan = async function() {
-  var pageNodesPromise = (async function() {
+  if (figma.ui) {
     try {
-      var page = figma.currentPage;
-      var topFrames = page.children || [];
-      var collected = [];
-      var CHUNK_SIZE = 10;
-
-      for (var i = 0; i < topFrames.length; i += CHUNK_SIZE) {
-        var chunk = topFrames.slice(i, i + CHUNK_SIZE);
-        var chunkData = chunk.map(function(n) {
-          return Object.assign(nodeToInfo(n), { childCount: "children" in n ? n.children.length : 0 });
-        });
-        collected = collected.concat(chunkData);
+      figma.ui.postMessage({ type: "index-progress", stage: "nodes", percent: 5, label: "Scanning canvas layers…" });
+    } catch(e) {}
+  }
 
-        // Stream chunk progressively if there are multiple chunks
-        if (topFrames.length > CHUNK_SIZE && figma.ui) {
-          try {
-            figma.ui.postMessage({ type: "index-chunk", nodes: chunkData });
-          } catch(e3) {}
-        }
+  var pageNodes = [];
+  try {
+    var page = figma.currentPage;
+    var topFrames = page.children || [];
+    var CHUNK_SIZE = 10;
+    var totalFrames = topFrames.length;
+
+    for (var i = 0; i < topFrames.length; i += CHUNK_SIZE) {
+      var chunk = topFrames.slice(i, i + CHUNK_SIZE);
+      var chunkData = chunk.map(function(n) {
+        return Object.assign(nodeToInfo(n), { childCount: "children" in n ? n.children.length : 0 });
+      });
+      pageNodes = pageNodes.concat(chunkData);
+
+      var nodePct = totalFrames > 0 ? Math.min(40, Math.round(5 + (pageNodes.length / totalFrames) * 35)) : 35;
+      if (figma.ui) {
+        try {
+          figma.ui.postMessage({
+            type: "index-progress",
+            stage: "nodes",
+            percent: nodePct,
+            label: "Layers: " + pageNodes.length + (totalFrames ? "/" + totalFrames : "")
+          });
+        } catch(e) {}
+      }
+
+      // Stream chunk progressively if there are multiple chunks
+      if (topFrames.length > CHUNK_SIZE && figma.ui) {
+        try {
+          figma.ui.postMessage({ type: "index-chunk", nodes: chunkData });
+        } catch(e3) {}
       }
-      return collected;
-    } catch (e) {}
-    return [];
-  })();
 
-  var stylesPromise = (async function() {
+      // Yield after every chunk so canvas/UI remains completely smooth
+      if (typeof yieldToUI === "function") {
+        await yieldToUI(0);
+      }
+    }
+  } catch (e) {}
+
+  if (typeof yieldToUI === "function") await yieldToUI(0);
+
+  if (figma.ui) {
     try {
-      if (handlers.get_styles) return await handlers.get_styles({});
-    } catch (e) {}
-    return null;
-  })();
+      figma.ui.postMessage({ type: "index-progress", stage: "styles", percent: 45, label: "Indexing color & text styles…" });
+    } catch(e) {}
+  }
+
+  var styles = null;
+  try {
+    if (handlers.get_styles) styles = await handlers.get_styles({});
+  } catch (e) {}
+
+  if (typeof yieldToUI === "function") await yieldToUI(0);
 
-  var varsPromise = (async function() {
+  if (figma.ui) {
     try {
-      if (handlers.get_variables) return await handlers.get_variables({});
-    } catch (e) {}
-    return null;
-  })();
+      figma.ui.postMessage({ type: "index-progress", stage: "variables", percent: 65, label: "Indexing variables & tokens…" });
+    } catch(e) {}
+  }
+
+  var variables = null;
+  try {
+    if (handlers.get_variables) variables = await handlers.get_variables({});
+  } catch (e) {}
 
-  var compsPromise = (async function() {
+  if (typeof yieldToUI === "function") await yieldToUI(0);
+
+  if (figma.ui) {
     try {
-      if (handlers.get_local_components) return await handlers.get_local_components({});
-    } catch (e) {}
-    return null;
-  })();
+      figma.ui.postMessage({ type: "index-progress", stage: "components", percent: 85, label: "Indexing components & sets…" });
+    } catch(e) {}
+  }
 
-  var results = await Promise.all([pageNodesPromise, stylesPromise, varsPromise, compsPromise]);
-  var pageNodes = results[0];
-  var styles = results[1];
-  var variables = results[2];
-  var components = results[3];
+  var components = null;
+  try {
+    if (handlers.get_local_components) components = await handlers.get_local_components({});
+  } catch (e) {}
+
+  if (figma.ui) {
+    try {
+      figma.ui.postMessage({ type: "index-progress", stage: "done", percent: 100, label: "Index ready" });
+    } catch(e) {}
+  }
+
+  var resolvedSid = figma.fileKey || (function() {
+    try { return figma.root.getPluginData("mcp_session_id") || "_default"; } catch(e) { return "_default"; }
+  })();
 
   return {
     fileName: figma.root ? figma.root.name : "unknown",
-    sessionId: figma.root ? figma.root.id : "_default",
+    sessionId: resolvedSid,
     pageNodes: pageNodes,
     styles: styles,
     variables: variables,
@@ -3749,46 +3827,66 @@ handlers.get_styles = async function() {
 
 // get_local_components — enhanced component listing with descriptions and properties
 handlers.get_local_components = async function() {
-  await figma.loadAllPagesAsync();
+  if (typeof figma.loadAllPagesAsync === "function") {
+    try { await figma.loadAllPagesAsync(); } catch (e) {}
+  }
   var comps = figma.root.findAllWithCriteria({ types: ["COMPONENT"] });
+  if (typeof yieldToUI === "function") await yieldToUI(0);
   var sets = figma.root.findAllWithCriteria({ types: ["COMPONENT_SET"] });
-
-  return {
-    components: comps.map(function(c) {
-      var info = {
-        id: c.id, name: c.name, key: c.key || null,
-        description: c.description || "",
-        setName: (c.parent && c.parent.type === "COMPONENT_SET") ? c.parent.name : null,
-        width: Math.round(c.width), height: Math.round(c.height),
-        page: c.parent ? (function findPage(n) {
-          while (n && n.type !== "PAGE") n = n.parent;
-          return n ? n.name : null;
-        })(c) : null,
-      };
-      // Component properties (variant props)
-      try {
-        if (c.componentPropertyDefinitions) {
-          var defs = c.componentPropertyDefinitions;
-          var props = {};
-          for (var key in defs) {
-            if (Object.prototype.hasOwnProperty.call(defs, key)) {
-              props[key] = { type: defs[key].type, defaultValue: defs[key].defaultValue };
-              if (defs[key].variantOptions) props[key].options = defs[key].variantOptions;
-            }
+  if (typeof yieldToUI === "function") await yieldToUI(0);
+
+  var componentList = [];
+  var COMP_BATCH_SIZE = 50;
+  for (var ci = 0; ci < comps.length; ci++) {
+    var c = comps[ci];
+    var info = {
+      id: c.id, name: c.name, key: c.key || null,
+      description: c.description || "",
+      setName: (c.parent && c.parent.type === "COMPONENT_SET") ? c.parent.name : null,
+      width: Math.round(c.width), height: Math.round(c.height),
+      page: c.parent ? (function findPage(n) {
+        while (n && n.type !== "PAGE") n = n.parent;
+        return n ? n.name : null;
+      })(c) : null,
+    };
+    // Component properties (variant props)
+    try {
+      if (c.componentPropertyDefinitions) {
+        var defs = c.componentPropertyDefinitions;
+        var props = {};
+        for (var key in defs) {
+          if (Object.prototype.hasOwnProperty.call(defs, key)) {
+            props[key] = { type: defs[key].type, defaultValue: defs[key].defaultValue };
+            if (defs[key].variantOptions) props[key].options = defs[key].variantOptions;
           }
-          info.properties = props;
         }
-      } catch(e) { /* skip properties */ }
-      return info;
-    }),
-    componentSets: sets.map(function(s) {
-      return {
-        id: s.id, name: s.name, key: s.key || null,
-        description: s.description || "",
-        variantCount: s.children ? s.children.length : 0,
-      };
-    }),
-    total: comps.length + sets.length,
+        info.properties = props;
+      }
+    } catch(e) { /* skip properties */ }
+    componentList.push(info);
+
+    if (ci > 0 && ci % COMP_BATCH_SIZE === 0 && typeof yieldToUI === "function") {
+      await yieldToUI(0);
+    }
+  }
+
+  var componentSets = [];
+  for (var si = 0; si < sets.length; si++) {
+    var s = sets[si];
+    componentSets.push({
+      id: s.id, name: s.name, key: s.key || null,
+      description: s.description || "",
+      variantCount: s.children ? s.children.length : 0,
+    });
+    if (si > 0 && si % COMP_BATCH_SIZE === 0 && typeof yieldToUI === "function") {
+      await yieldToUI(0);
+    }
+  }
+
+  return {
+    components: componentList,
+    componentSets: componentSets,
+    total: componentList.length + componentSets.length,
   };
 };
 
@@ -3871,12 +3969,17 @@ handlers.get_variables = async function() {
           values: values,
           description: v.description || "",
         });
+
+        if (vi > 0 && vi % 50 === 0 && typeof yieldToUI === "function") {
+          await yieldToUI(0);
+        }
       }
       collections.push({
         id: col.id, name: col.name,
         modes: col.modes.map(function(m) { return { id: m.modeId, name: m.name }; }),
         variables: variables,
       });
+      if (typeof yieldToUI === "function") await yieldToUI(0);
     }
   } catch(e) {
     return { error: "Variables API not available: " + e.message, collections: [] };
@@ -3884,6 +3987,131 @@ handlers.get_variables = async function() {
   return { collections: collections };
 };
 
+// ─── EXPORT ASSETS (Batch Icon & Image Extractor) ────────────────────────────
+handlers.export_assets = async function(params) {
+  var id = params ? (params.id || params.nodeId) : null;
+  var targetNode = null;
+  if (id) targetNode = await findNodeByIdAsync(id);
+  if (!targetNode) {
+    var sel = figma.currentPage.selection;
+    targetNode = sel && sel.length > 0 ? sel[0] : figma.currentPage;
+  }
+  if (!targetNode) throw new Error("No node found to export assets from");
+
+  var icons = [];
+  var images = [];
+  var seenNames = {};
+
+  function sanitizeAssetName(rawName, fallback) {
+    var name = (rawName || fallback)
+      .toLowerCase()
+      .replace(/^icon[s\/_\-\s]+/, '')
+      .replace(/^ic[_\-\s]+/, '')
+      .replace(/[\/\s_\.]+/g, '-')
+      .replace(/[^a-z0-9\-]/g, '')
+      .replace(/^-+|-+$/g, '');
+    if (!name) name = fallback;
+    if (seenNames[name]) {
+      seenNames[name]++;
+      return name + "-" + seenNames[name];
+    }
+    seenNames[name] = 1;
+    return name;
+  }
+
+  function isVectorIcon(nd) {
+    if (!nd || nd.visible === false) return false;
+    var t = nd.type;
+    if (t === "VECTOR" || t === "BOOLEAN_OPERATION" || t === "STAR" || t === "POLYGON") return true;
+    if ((t === "FRAME" || t === "COMPONENT" || t === "INSTANCE" || t === "GROUP") && nd.width <= 96 && nd.height <= 96) {
+      var n = nd.name.toLowerCase();
+      if (n.indexOf("icon") >= 0 || n.indexOf("ic_") >= 0 || n.indexOf("ic-") >= 0) return true;
+      if (nd.children && nd.children.length > 0 && nd.children.length <= 8) {
+        var allVectors = nd.children.every(function(c) {
+          return c.type === "VECTOR" || c.type === "BOOLEAN_OPERATION" || c.type === "LINE" || c.type === "ELLIPSE" || c.type === "RECTANGLE";
+        });
+        if (allVectors) return true;
+      }
+    }
+    return false;
+  }
+
+  function hasImageFill(nd) {
+    if (!nd || !nd.fills || !Array.isArray(nd.fills)) return false;
+    return nd.fills.some(function(f) { return f && f.type === "IMAGE" && f.visible !== false; });
+  }
+
+  var nodesToInspect = [];
+  function collectAssetNodes(nd, depth) {
+    if (!nd || nd.visible === false || depth > 20) return;
+    if (isVectorIcon(nd)) {
+      nodesToInspect.push({ node: nd, kind: "icon" });
+      return;
+    }
+    if (hasImageFill(nd)) {
+      nodesToInspect.push({ node: nd, kind: "image" });
+    }
+    if (nd.children && Array.isArray(nd.children)) {
+      for (var ci = 0; ci < nd.children.length; ci++) {
+        collectAssetNodes(nd.children[ci], depth + 1);
+      }
+    }
+  }
+
+  if (targetNode === figma.currentPage) {
+    for (var pi = 0; pi < targetNode.children.length; pi++) {
+      collectAssetNodes(targetNode.children[pi], 0);
+    }
+  } else {
+    collectAssetNodes(targetNode, 0);
+  }
+
+  var exportLimit = Math.min(nodesToInspect.length, 60);
+  for (var i = 0; i < exportLimit; i++) {
+    var item = nodesToInspect[i];
+    var nd = item.node;
+    var baseName = sanitizeAssetName(nd.name, "asset-" + (i + 1));
+
+    if (item.kind === "icon") {
+      try {
+        var svgBytes = await nd.exportAsync({ format: "SVG" });
+        var svgStr = String.fromCharCode.apply(null, Array.from(svgBytes));
+        icons.push({
+          id: nd.id,
+          name: baseName,
+          fileName: baseName + ".svg",
+          width: Math.round(nd.width),
+          height: Math.round(nd.height),
+          svg: svgStr
+        });
+      } catch (e) {}
+    } else if (item.kind === "image") {
+      try {
+        var pngBytes = await nd.exportAsync({ format: "PNG", constraint: { type: "SCALE", value: 2 } });
+        var b64 = uint8ArrayToBase64(pngBytes);
+        images.push({
+          id: nd.id,
+          name: baseName,
+          fileName: baseName + ".png",
+          width: Math.round(nd.width),
+          height: Math.round(nd.height),
+          dataUrl: "data:image/png;base64," + b64
+        });
+      } catch (e) {}
+    }
+  }
+
+  return {
+    success: true,
+    sourceNodeId: targetNode.id,
+    sourceNodeName: targetNode.name,
+    totalIcons: icons.length,
+    totalImages: images.length,
+    icons: icons,
+    images: images
+  };
+};
+
 
 // ── plugin-src/handlers-tokens.js ──
 // ─── DESIGN TOKEN OPERATIONS (v1.7.0) ───────────────────────────────────────
@@ -5148,12 +5376,51 @@ figma.clientStorage.getAsync("mcp_window_size").then(function(saved) {
   }
 }).catch(function() {});
 
+// ─── UNIQUE SESSION IDENTIFIER (Multi-tab Support) ───────────────────────────
+// In Figma, figma.root.id is always "0:0" across all files. To support running
+// multiple plugins concurrently across multiple tabs/files, generate and persist
+// a unique document session ID in document pluginData.
+function getSavedFileKey() {
+  if (figma.fileKey) return figma.fileKey;
+  try {
+    var saved = figma.root.getPluginData("figma_file_key");
+    if (saved && saved.length > 0) return saved;
+  } catch(e) {}
+  return null;
+}
+
+function getOrCreateSessionId() {
+  var fk = getSavedFileKey();
+  if (fk) {
+    return fk;
+  }
+  try {
+    var stored = figma.root.getPluginData("mcp_session_id");
+    if (stored && stored.length > 0) {
+      return stored;
+    }
+  } catch(e) {}
+
+  var rand = Math.random().toString(36).substring(2, 10);
+  var ts = Date.now().toString(36);
+  var newId = "doc_" + rand + "_" + ts;
+  try {
+    figma.root.setPluginData("mcp_session_id", newId);
+  } catch(e) {}
+  return newId;
+}
+
+var currentSessionId = getOrCreateSessionId();
+var currentFileName = figma.root ? figma.root.name : "Untitled";
+var currentFileKey = getSavedFileKey();
+
 // Broadcast active file / session metadata on startup
 try {
   figma.ui.postMessage({
     type: "session-info",
-    sessionId: figma.root.id,
-    fileName: figma.root.name
+    sessionId: currentSessionId,
+    fileName: currentFileName,
+    fileKey: currentFileKey
   });
 } catch (e) {}
 
@@ -5162,13 +5429,33 @@ figma.on("selectionchange", function() {
   try {
     var sel = figma.currentPage.selection;
     var summary = [];
+    var fullNode = null;
     for (var i = 0; i < Math.min(sel.length, 5); i++) {
-      summary.push({ id: sel[i].id, name: sel[i].name, type: sel[i].type });
+      var n = sel[i];
+      // If node is an internal instance sub-layer (starts with I...), find its main component instance or top frame
+      var mainId = n.id;
+      if (mainId.startsWith("I") && mainId.indexOf(";") !== -1) {
+        var parts = mainId.split(";");
+        mainId = parts[parts.length - 1]; // Use real canonical node id
+      }
+      summary.push({
+        id: n.id,
+        mainId: mainId,
+        name: n.name,
+        type: n.type,
+        width: typeof n.width === "number" ? Math.round(n.width) : undefined,
+        height: typeof n.height === "number" ? Math.round(n.height) : undefined
+      });
+    }
+    if (sel.length === 1 && typeof nodeToInfo === "function") {
+      try { fullNode = nodeToInfo(sel[0]); } catch(e0) {}
     }
     figma.ui.postMessage({
       type: "selection-change",
       count: sel.length,
-      selection: summary
+      pageName: figma.currentPage ? figma.currentPage.name : undefined,
+      selection: summary,
+      fullNode: fullNode
     });
   } catch (e) {}
 });
@@ -5190,6 +5477,28 @@ function onDocChange(event) {
       var ids = Array.from(pendingChangedNodeIds);
       pendingChangedNodeIds.clear();
 
+      if (ids.length === 1) {
+        try {
+          var singleNode = await findNodeByIdAsync(ids[0]);
+          if (singleNode) {
+            figma.ui.postMessage({
+              type: "delta-diff",
+              id: singleNode.id,
+              diff: {
+                name: singleNode.name,
+                characters: "characters" in singleNode ? singleNode.characters : undefined,
+                visible: singleNode.visible,
+                width: singleNode.width,
+                height: singleNode.height,
+                x: singleNode.x,
+                y: singleNode.y
+              }
+            });
+            return;
+          }
+        } catch(e1) {}
+      }
+
       if (ids.length > 0 && ids.length <= 15) {
         // Incremental micro-diff update for fast real-time editing
         var diffNodes = [];
@@ -5209,24 +5518,27 @@ function onDocChange(event) {
 
       // Fallback for large batch changes: mark dirty or trigger background sync
       figma.ui.postMessage({ type: "document-change" });
-    }, 800);
+    }, 500);
   } catch (e) {}
 }
 
-// In dynamic-page mode, Figma requires figma.loadAllPagesAsync() before registering documentchange
-if (typeof figma.loadAllPagesAsync === "function") {
-  figma.loadAllPagesAsync().then(function() {
+// In dynamic-page mode, Figma requires figma.loadAllPagesAsync() before registering documentchange.
+// Delay loading all pages slightly so plugin UI opens and paints immediately without UI freeze.
+setTimeout(function() {
+  if (typeof figma.loadAllPagesAsync === "function") {
+    figma.loadAllPagesAsync().then(function() {
+      try {
+        figma.on("documentchange", onDocChange);
+      } catch (e) {}
+    }).catch(function() {});
+  } else {
     try {
       figma.on("documentchange", onDocChange);
     } catch (e) {}
-  }).catch(function() {});
-} else {
-  try {
-    figma.on("documentchange", onDocChange);
-  } catch (e) {}
-}
+  }
+}, 800);
 
-// Background initial scan after 1.2s startup delay (ensures UI WebSocket is connected)
+// Background initial scan after 1.8s startup delay (ensures UI is fully rendered and WebSocket connected)
 setTimeout(async function() {
   try {
     if (handlers.index_scan) {
@@ -5235,13 +5547,13 @@ setTimeout(async function() {
       figma.ui.postMessage({
         type: "index-update",
         data: scanResult,
-        fileName: figma.root ? figma.root.name : "unknown",
-        sessionId: figma.root ? figma.root.id : "_default",
+        fileName: currentFileName,
+        sessionId: currentSessionId,
         startMs: startMs
       });
     }
   } catch (e) {}
-}, 1200);
+}, 1800);
 
 // ─── DISPATCHER ───────────────────────────────────────────────────────────────
 
@@ -5288,6 +5600,72 @@ figma.ui.onmessage = async (request) => {
     return;
   }
 
+  // Set and persist Figma File Key
+  if (request.type === "set-file-key") {
+    try {
+      var newFileKey = (request.fileKey || "").trim();
+      if (newFileKey) {
+        figma.root.setPluginData("figma_file_key", newFileKey);
+        currentFileKey = newFileKey;
+        figma.ui.postMessage({
+          type: "session-info",
+          sessionId: currentSessionId,
+          fileName: currentFileName,
+          fileKey: newFileKey
+        });
+        figma.notify("Figma File Key saved!", { timeout: 1500 });
+      }
+    } catch(e) {}
+    return;
+  }
+
+  // Toast notification from UI
+  if (request.type === "notify") {
+    try {
+      if (request.message) {
+        figma.notify(request.message, { timeout: request.timeout || 1500, error: request.error || false });
+      }
+    } catch(e) {}
+    return;
+  }
+
+  // Zoom to selection when clicked on selection bar
+  if (request.type === "zoom-to-selection") {
+    try {
+      if (figma.currentPage.selection.length > 0) {
+        figma.viewport.scrollAndZoomIntoView(figma.currentPage.selection);
+        figma.notify("Focused on selection", { timeout: 1000 });
+      }
+    } catch(e) {}
+    return;
+  }
+
+  // Export selection image as PNG for UI clipboard/download
+  if (request.type === "export-selection-image") {
+    try {
+      var sel = figma.currentPage.selection;
+      if (!sel || sel.length === 0) {
+        figma.notify("Please select a layer to capture", { timeout: 1500 });
+        return;
+      }
+      var targetNode = sel[0];
+      var scale = request.scale || 2;
+      var bytes = await targetNode.exportAsync({
+        format: "PNG",
+        constraint: { type: "SCALE", value: scale }
+      });
+      figma.ui.postMessage({
+        type: "selection-image-exported",
+        nodeId: targetNode.id,
+        nodeName: targetNode.name,
+        bytes: Array.from(bytes)
+      });
+    } catch (err) {
+      figma.notify("Export failed: " + (err && err.message ? err.message : String(err)), { error: true });
+    }
+    return;
+  }
+
   // Handle manual reindex request from UI
   if (request.type === "manual-reindex") {
     try {
@@ -5297,8 +5675,8 @@ figma.ui.onmessage = async (request) => {
         figma.ui.postMessage({
           type: "index-update",
           data: scanResult,
-          fileName: figma.root ? figma.root.name : "unknown",
-          sessionId: figma.root ? figma.root.id : "_default",
+          fileName: currentFileName,
+          sessionId: currentSessionId,
           startMs: startMs
         });
       }