@clovis500c/figma-bridge 1.8.0 → 1.12.0

package/dist/server.js

@@ -47,7 +47,7 @@ var __esm = (fn, res, err) => () => {
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // package.json
-var version = "1.8.0";
+var version = "1.12.0";
 var init_package = () => {};
 
 // node_modules/zod/v3/helpers/util.js
@@ -24772,6 +24772,7 @@ var init_wrapper = __esm(() => {
 });
 
 // src/bridge.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 import { connect } from "node:net";
@@ -24998,6 +24999,10 @@ class Hub {
           ws.data.session.fileName = msg.fileName;
         if (typeof msg.page === "string")
           ws.data.session.page = msg.page;
+        if (typeof msg.editorType === "string")
+          ws.data.session.editorType = msg.editorType;
+        if (typeof msg.pageId === "string")
+          ws.data.session.pageId = msg.pageId;
       }
     } else if (ws.data.role === "agent") {
       if (msg.t === "req")
@@ -25025,6 +25030,9 @@ class Hub {
         page: String(s.page || ""),
         channel,
         version: msg.version,
+        editorType: typeof s.editorType === "string" ? s.editorType : undefined,
+        fileKey: typeof s.fileKey === "string" && s.fileKey ? s.fileKey : undefined,
+        pageId: typeof s.pageId === "string" ? s.pageId : undefined,
         connectedAt: Date.now()
       };
       const previous = this.plugins.get(session.id);
@@ -25216,7 +25224,7 @@ class Bridge {
         throw new BridgeError(this.lastError ?? `The bridge could not open or join port ${this.opts.port}.`, "OFFLINE");
       }
       try {
-        return await this.send(method, params, timeoutMs);
+        return await this.send(method, params, timeoutMs, await this.selectionFor(method));
       } catch (e) {
         const retryable = e instanceof BridgeError && (e.code === "NO_SESSION" || e.code === "OFFLINE");
         if (!retryable || Date.now() > deadline)
@@ -25225,10 +25233,17 @@ class Bridge {
       }
     }
   }
-  send(method, params, timeoutMs) {
+  async selectionFor(method) {
+    const file = method === "$sessions" ? undefined : callTarget.getStore()?.file;
+    if (!file)
+      return this.selection;
+    const s = await this.find(file);
+    return { id: s.id, fileName: s.fileName };
+  }
+  send(method, params, timeoutMs, sel) {
     return new Promise((resolve, reject) => {
       const id = randomUUID();
-      const msg = { t: "req", id, method, params, sel: this.selection, timeoutMs };
+      const msg = { t: "req", id, method, params, sel, timeoutMs };
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new BridgeError(`${method} got no answer after ${Math.round(timeoutMs / 1000)} s. Figma may be frozen by a long synchronous script.`, "TIMEOUT"));
@@ -25263,6 +25278,18 @@ class Bridge {
     return this.request("$sessions", {}, 5000, 1500);
   }
   async select(name) {
+    const hit = await this.find(name);
+    this.selection = { id: hit.id, fileName: hit.fileName };
+    return hit;
+  }
+  async current() {
+    const file = callTarget.getStore()?.file;
+    if (file)
+      return this.find(file);
+    const list = await this.sessions().catch(() => []);
+    return list.find((s) => s.id === this.selection.id) ?? (list.length === 1 ? list[0] : null);
+  }
+  async find(name) {
     const list = await this.sessions();
     const q = name.trim().toLowerCase();
     const hit = list.find((s) => s.id === name) ?? list.find((s) => s.fileName.toLowerCase() === q) ?? (list.filter((s) => s.fileName.toLowerCase().includes(q)).length === 1 ? list.find((s) => s.fileName.toLowerCase().includes(q)) : undefined);
@@ -25270,15 +25297,15 @@ class Bridge {
       const names = list.map((s) => `"${s.fileName}"`).join(", ") || "none";
       throw new BridgeError(`No unique connected file matches "${name}". Connected: ${names}.`, "NOT_FOUND");
     }
-    this.selection = { id: hit.id, fileName: hit.fileName };
     return hit;
   }
 }
-var BRIDGE_NAME = "figma-bridge", PROTOCOL_VERSION = 1, CHUNK_CHARS, MAX_MESSAGE_CHARS, PARTIAL_TTL_MS = 60000, INFLIGHT_TTL_MS = 180000, HANDSHAKE_MS = 2500, PING_MS = 20000, IDLE_MS = 120000, BridgeError, mb = (chars) => `${(chars / (1 << 20)).toFixed(1)} MB`, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), NO_PLUGIN_HELP;
+var BRIDGE_NAME = "figma-bridge", PROTOCOL_VERSION = 1, CHUNK_CHARS, MAX_MESSAGE_CHARS, PARTIAL_TTL_MS = 60000, INFLIGHT_TTL_MS = 180000, HANDSHAKE_MS = 2500, PING_MS = 20000, IDLE_MS = 120000, callTarget, BridgeError, mb = (chars) => `${(chars / (1 << 20)).toFixed(1)} MB`, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), NO_PLUGIN_HELP;
 var init_bridge = __esm(() => {
   init_wrapper();
   CHUNK_CHARS = 1 << 20;
   MAX_MESSAGE_CHARS = 256 << 20;
+  callTarget = new AsyncLocalStorage;
   BridgeError = class BridgeError extends Error {
     code;
     details;
@@ -26799,9 +26826,1647 @@ var init_codegen = __esm(() => {
   RADII = { 2: "rounded-sm", 4: "rounded", 6: "rounded-md", 8: "rounded-lg", 12: "rounded-xl", 16: "rounded-2xl", 24: "rounded-3xl" };
 });
 
+// src/diagram.ts
+function parseDiagram(source) {
+  const lines = source.replace(/%%.*$/gm, "").split(/\n|;/).map((l) => l.trim()).filter(Boolean);
+  const d = { direction: "TB", nodes: [], edges: [], subgraphs: [] };
+  const byId = new Map;
+  const stack = [];
+  const node = (ref) => {
+    const m = /^([A-Za-z0-9_\-.$]+)\s*(.*)$/s.exec(ref.trim());
+    if (!m)
+      return null;
+    const id = m[1];
+    const rest = m[2].trim();
+    let n = byId.get(id);
+    if (!n) {
+      n = { id, label: id, shape: "rounded" };
+      byId.set(id, n);
+      d.nodes.push(n);
+    }
+    if (rest) {
+      for (const [re, shape] of SHAPES) {
+        const s = re.exec(rest);
+        if (s) {
+          n.label = unquote(s[1]);
+          n.shape = shape;
+          break;
+        }
+      }
+    }
+    for (const g of stack)
+      if (!g.nodes.includes(id))
+        g.nodes.push(id);
+    return id;
+  };
+  for (const line of lines) {
+    const header = /^(?:flowchart|graph)\s*(TB|TD|BT|LR|RL)?\b/i.exec(line);
+    if (header) {
+      const dir = (header[1] ?? "TB").toUpperCase();
+      d.direction = dir === "TD" ? "TB" : dir;
+      continue;
+    }
+    const sub = /^subgraph\s+([^\s[]+)(?:\s*\[(.*)\])?\s*(.*)$/i.exec(line);
+    if (sub) {
+      const g = { id: sub[1], label: unquote(sub[2] ?? (sub[3] || sub[1])), nodes: [] };
+      d.subgraphs.push(g);
+      stack.push(g);
+      continue;
+    }
+    if (/^end$/i.test(line)) {
+      stack.pop();
+      continue;
+    }
+    if (/^(direction|classDef|class|style|linkStyle|click)\b/.test(line))
+      continue;
+    const parts = [];
+    const links = [];
+    let rest = line;
+    for (;; ) {
+      const m = EDGE.exec(rest);
+      if (!m) {
+        parts.push(rest);
+        break;
+      }
+      parts.push(rest.slice(0, m.index));
+      let op = m[1];
+      let label = m[2];
+      const inline = /^(--|==|-\.)\s+(.+?)\s+(-->|==>|\.->)$/.exec(op);
+      if (inline) {
+        label = inline[2];
+        op = inline[1] === "--" ? "-->" : inline[1] === "==" ? "==>" : "-.->";
+      }
+      links.push({ op, label: label?.trim() || undefined });
+      rest = rest.slice(m.index + m[0].length);
+    }
+    const groups = parts.map((p) => p.split(/\s+&\s+/).map(node).filter((x) => !!x));
+    links.forEach((l, i) => {
+      for (const from of groups[i] ?? []) {
+        for (const to of groups[i + 1] ?? []) {
+          d.edges.push({ from, to, label: l.label, dashed: l.op.includes("."), thick: l.op.includes("="), arrow: />$/.test(l.op) });
+        }
+      }
+    });
+  }
+  return d;
+}
+function layoutDiagram(d, opts = {}) {
+  const size = opts.size ?? defaultSize;
+  const ids = d.nodes.map((n) => n.id);
+  const out = new Map(ids.map((i) => [i, []]));
+  const inn = new Map(ids.map((i) => [i, []]));
+  const state = new Map;
+  const forward = [];
+  const adj = new Map(ids.map((i) => [i, []]));
+  for (const e of d.edges)
+    if (e.from !== e.to)
+      adj.get(e.from).push(e.to);
+  const dfs = (v) => {
+    state.set(v, 1);
+    for (const w of adj.get(v)) {
+      if (state.get(w) === 1)
+        continue;
+      forward.push([v, w]);
+      if (!state.get(w))
+        dfs(w);
+    }
+    state.set(v, 2);
+  };
+  for (const v of ids)
+    if (!state.get(v))
+      dfs(v);
+  for (const [a, b] of forward) {
+    out.get(a).push(b);
+    inn.get(b).push(a);
+  }
+  const layer = new Map;
+  const visit = (v) => {
+    if (layer.has(v))
+      return layer.get(v);
+    layer.set(v, 0);
+    const l = Math.max(0, ...inn.get(v).map((u) => visit(u) + 1));
+    layer.set(v, l);
+    return l;
+  };
+  for (const v of ids)
+    visit(v);
+  const layers = [];
+  for (const v of ids)
+    (layers[layer.get(v)] ??= []).push(v);
+  const pos = new Map;
+  const index = () => layers.forEach((l) => l.forEach((v, i) => pos.set(v, i)));
+  index();
+  for (let sweep = 0;sweep < 4; sweep++) {
+    const down = sweep % 2 === 0;
+    const order = down ? layers.slice(1) : layers.slice(0, -1).reverse();
+    for (const l of order) {
+      const bary = (v) => {
+        const ns = down ? inn.get(v) : out.get(v);
+        return ns.length ? ns.reduce((a, u) => a + pos.get(u), 0) / ns.length : pos.get(v);
+      };
+      l.sort((a, b) => bary(a) - bary(b));
+      l.forEach((v, i) => pos.set(v, i));
+    }
+  }
+  const horizontal = d.direction === "LR" || d.direction === "RL";
+  const gap = opts.gap ?? 60;
+  const layerGap = opts.layerGap ?? 100;
+  const sizes = new Map(d.nodes.map((n) => [n.id, size(n)]));
+  const along = (v) => horizontal ? sizes.get(v).h : sizes.get(v).w;
+  const across = (v) => horizontal ? sizes.get(v).w : sizes.get(v).h;
+  const spans = layers.map((l) => l.reduce((a, v) => a + along(v), 0) + gap * Math.max(0, l.length - 1));
+  const widest = Math.max(0, ...spans);
+  const positions = new Map;
+  let depth = 0;
+  layers.forEach((l, li) => {
+    const thickness = Math.max(...l.map(across));
+    let cursor = (widest - spans[li]) / 2;
+    for (const v of l) {
+      const s = sizes.get(v);
+      const main = cursor;
+      const cross = depth + (thickness - across(v)) / 2;
+      positions.set(v, horizontal ? { x: cross, y: main, w: s.w, h: s.h } : { x: main, y: cross, w: s.w, h: s.h });
+      cursor += along(v) + gap;
+    }
+    depth += thickness + layerGap;
+  });
+  const total = Math.max(0, depth - layerGap);
+  if (d.direction === "BT" || d.direction === "RL") {
+    for (const p of positions.values()) {
+      if (horizontal)
+        p.x = total - p.x - p.w;
+      else
+        p.y = total - p.y - p.h;
+    }
+  }
+  return { positions, width: horizontal ? total : widest, height: horizontal ? widest : total };
+}
+function defaultSize(n) {
+  const lines = n.label.split(`
+`);
+  const longest = Math.max(...lines.map((l) => l.length));
+  const w = Math.min(320, Math.max(n.shape === "diamond" ? 180 : 160, longest * 9 + 48));
+  const h = Math.max(n.shape === "diamond" ? 120 : 80, lines.length * 22 + 40);
+  return n.shape === "ellipse" ? { w, h: Math.max(h, 100) } : { w, h };
+}
+function diagramSpec(spec) {
+  const d = parseDiagram(String(spec.source ?? spec.mermaid ?? ""));
+  if (!d.nodes.length)
+    throw new Error('diagram: no nodes found. Example: source:"flowchart LR\\n A[Start] --> B{OK?}\\n B -->|yes| C(Done)"');
+  const stickies = spec.as === "stickies";
+  const STICKY = { w: 240, h: 240 };
+  const lay = layoutDiagram(d, stickies ? { size: () => STICKY, gap: 80, layerGap: 120 } : {});
+  const pad = 80;
+  const head = 60;
+  const inGroup = new Map;
+  for (const g of d.subgraphs)
+    for (const id of g.nodes)
+      if (!inGroup.has(id))
+        inGroup.set(id, g);
+  const nodeSpec = (n, dx, dy) => {
+    const p = lay.positions.get(n.id);
+    const base = { name: n.label.split(`
+`)[0], key: `${spec.key ?? "diagram"}:${n.id}`, x: Math.round(p.x + dx), y: Math.round(p.y + dy) };
+    return stickies ? { ...base, type: "sticky", text: n.label, color: spec.color ?? "yellow" } : { ...base, type: "shape", shape: n.shape, text: n.label, w: Math.round(p.w), h: Math.round(p.h), ...spec.color ? { fill: spec.color } : {} };
+  };
+  const children = [];
+  for (const g of d.subgraphs) {
+    const members = g.nodes.filter((id) => inGroup.get(id) === g).map((id) => d.nodes.find((n) => n.id === id));
+    if (!members.length)
+      continue;
+    const ps = members.map((n) => lay.positions.get(n.id));
+    const x0 = Math.min(...ps.map((p) => p.x)) - 40;
+    const y0 = Math.min(...ps.map((p) => p.y)) - head;
+    const x1 = Math.max(...ps.map((p) => p.x + p.w)) + 40;
+    const y1 = Math.max(...ps.map((p) => p.y + p.h)) + 40;
+    children.push({
+      type: "section",
+      name: g.label,
+      x: Math.round(x0 + pad),
+      y: Math.round(y0 + pad + head),
+      w: Math.round(x1 - x0),
+      h: Math.round(y1 - y0),
+      children: members.map((n) => nodeSpec(n, -x0, -y0))
+    });
+  }
+  for (const n of d.nodes)
+    if (!inGroup.has(n.id))
+      children.push(nodeSpec(n, pad, pad + head));
+  for (const e of d.edges) {
+    children.push({
+      type: "connector",
+      from: `${spec.key ?? "diagram"}:${e.from}`,
+      to: `${spec.key ?? "diagram"}:${e.to}`,
+      ...e.label ? { label: e.label } : {},
+      ...e.dashed ? { dashed: true } : {},
+      ...e.thick ? { strokeWidth: 4 } : {},
+      ...e.arrow ? {} : { endArrow: "none" },
+      line: spec.line ?? "elbowed"
+    });
+  }
+  return {
+    type: "section",
+    name: spec.name ?? "Diagram",
+    ...spec.x !== undefined ? { x: spec.x } : {},
+    ...spec.y !== undefined ? { y: spec.y } : {},
+    w: Math.round(lay.width + pad * 2),
+    h: Math.round(lay.height + pad * 2 + head),
+    children
+  };
+}
+var SHAPES, unquote = (s) => s.trim().replace(/^"(.*)"$/s, "$1").replace(/<br\s*\/?>/gi, `
+`), EDGE;
+var init_diagram = __esm(() => {
+  SHAPES = [
+    [/^\(\((.*)\)\)$/s, "ellipse"],
+    [/^\(\[(.*)\]\)$/s, "rounded"],
+    [/^\[\[(.*)\]\]$/s, "process"],
+    [/^\[\((.*)\)\]$/s, "database"],
+    [/^\{\{(.*)\}\}$/s, "hexagon"],
+    [/^\[\/(.*)\/\]$/s, "parallelogram"],
+    [/^\[\\(.*)\\\]$/s, "parallelogramleft"],
+    [/^\[\/(.*)\\\]$/s, "trapezoid"],
+    [/^>(.*)\]$/s, "chevron"],
+    [/^\((.*)\)$/s, "rounded"],
+    [/^\{(.*)\}$/s, "diamond"],
+    [/^\[(.*)\]$/s, "square"]
+  ];
+  EDGE = /\s*(<?-{2,}>|<?-\.+->|<?={2,}>|-{3,}|={3,}|-\.+-|--\s+[^-]+?\s+-->|==\s+[^=]+?\s+==>|-\.\s+[^.]+?\s+\.->)\s*(?:\|([^|]*)\|)?\s*/;
+});
+
+// src/guides.ts
+function registerGuides(server, docs) {
+  for (const p of PROMPTS) {
+    const argsSchema = {};
+    for (const [k, d] of Object.entries(p.args))
+      argsSchema[k] = string2().optional().describe(d);
+    server.registerPrompt(p.name, { title: p.title, description: p.description, argsSchema }, (args) => text(p.render(args ?? {})));
+  }
+  server.registerResource("build-spec", RESOURCES.build, { title: "build spec reference", description: "Every node type and property the build tool accepts, with examples.", mimeType: "text/markdown" }, async (uri) => ({ contents: [{ uri: uri.href, mimeType: "text/markdown", text: buildSpecMarkdown(docs.buildSpec) }] }));
+  server.registerResource("workflow", RESOURCES.workflow, { title: "Figma Bridge workflow", description: "How to work with Figma Bridge: the workflow, rules and every tool.", mimeType: "text/markdown" }, async (uri) => ({ contents: [{ uri: uri.href, mimeType: "text/markdown", text: workflowMarkdown(docs.instructions, docs.tools()) }] }));
+}
+function buildSpecMarkdown(spec) {
+  const lines = spec.split(`
+`);
+  const out = ["# build spec reference", "", lines[0], ""];
+  for (const line of lines.slice(1)) {
+    const m = /^([A-Z]{2,}(?: [A-Z]{2,})*)((?: \([^)]*\))?(?: files)?):\s*(.*)$/.exec(line);
+    if (m && !/^Example/.test(line)) {
+      const title = m[1] + m[2];
+      out.push(`## ${title[0]}${title.slice(1).toLowerCase()}`, "", m[3], "");
+    } else if (/^Example:/.test(line))
+      out.push("## Example", "", "```json", line.replace(/^Example:\s*/, ""), "```", "");
+    else
+      out.push(line, "");
+  }
+  return out.join(`
+`).replace(/\n{3,}/g, `
+
+`);
+}
+function workflowMarkdown(instructions, tools) {
+  const first = (d) => (/^(.*?[.!?])(\s|$)/s.exec(d.replace(/\s+/g, " "))?.[1] ?? d).slice(0, 220);
+  return [
+    "# Working with Figma Bridge",
+    "",
+    ...instructions.map((l) => /^\d\./.test(l) ? l : `- ${l}`),
+    "",
+    "## Tools",
+    "",
+    ...tools.map((t) => `- **${t.name}**${t.title ? ` (${t.title})` : ""}: ${first(t.description)}`),
+    "",
+    "## Prompts",
+    "",
+    ...PROMPTS.map((p) => `- **${p.name}**: ${p.description}`),
+    "",
+    `Full build spec: ${RESOURCES.build}`,
+    ""
+  ].join(`
+`);
+}
+var RESOURCES, text = (t) => ({ messages: [{ role: "user", content: { type: "text", text: t.trim() } }] }), opt = (v, fallback) => v && v.trim() ? v.trim() : fallback, PROMPTS;
+var init_guides = __esm(() => {
+  init_zod();
+  RESOURCES = {
+    build: "figma-bridge://docs/build-spec",
+    workflow: "figma-bridge://docs/workflow"
+  };
+  PROMPTS = [
+    {
+      name: "new-screen",
+      title: "Design a new screen",
+      description: "Design a screen from a description, reusing the file's design system.",
+      args: { description: "What the screen is for and what it contains", platform: "desktop (1440), tablet (834) or mobile (390); default desktop" },
+      render: (a) => `
+Design a new ${opt(a.platform, "desktop")} screen in the connected Figma file: ${opt(a.description, "(ask me what the screen is for)")}.
+1. get_context, then get_design_system. Reuse its color and text styles, variables and components (style:, var:, {component}) instead of raw values.
+2. Build it with build: one call per section (header, hero, content, footer…), auto-layout everywhere, frames named after what they are, width ${a.platform === "mobile" ? 390 : a.platform === "tablet" ? 834 : 1440}.
+3. screenshot {returnImage:true} the result and look at it critically: spacing rhythm, alignment, hierarchy, contrast.
+4. audit the frame and fix every error and warning.
+5. Tell me what you built and what you would improve next.`
+    },
+    {
+      name: "apply-design-system",
+      title: "Apply the design system",
+      description: "Make a screen use the file's variables, styles and components.",
+      args: { target: "Layer name or id (default: the selection)" },
+      render: (a) => `
+Apply the file's design system to ${opt(a.target, "the selected layers (use wait_for_selection if nothing is selected)")}.
+1. get_design_system to see the variables, styles and components available, and describe the target.
+2. checkpoint {action:"save"} on the target first.
+3. audit {fix:true} on it: raw colors and numbers get bound to matching variables, matching text styles are applied, default layer names are fixed.
+4. For what remains (near-miss colors, text without a matching style, frames that should be component instances), fix it with build or run_script: prefer replacing ad-hoc elements by instances of the existing components.
+5. audit {scope:"design-system", nodeId} before and after, and report the score change and anything you could not map.`
+    },
+    {
+      name: "reproduce-screenshot",
+      title: "Reproduce a screenshot",
+      description: "Rebuild a mockup or screenshot as an editable, auto-layout frame and check it pixel by pixel.",
+      args: { image: "Local path or URL of the image", width: "Width of the frame in px (default: the image's width)" },
+      render: (a) => `
+Reproduce ${opt(a.image, "the image I give you")} as an editable Figma frame${a.width ? ` ${a.width} px wide` : ""}.
+1. Look at the image carefully. get_design_system and reuse what matches.
+2. build it at the image's size, with auto-layout and real text (not images of text). Icons: search_icons, then {icon:"set:name"}.
+3. compare {nodeId, reference:"${opt(a.image, "<image>")}", returnImage:true}. Fix the largest regions first (layout and size before color and detail), then compare again.
+4. Stop when mismatchPercent no longer drops; report the final number and what still differs.`
+    },
+    {
+      name: "import-website",
+      title: "Import a website",
+      description: "Turn a web page into editable Figma frames at several widths, then clean them up.",
+      args: { url: "The page URL, or a local .html path", viewports: "Comma-separated widths, default 1440,390" },
+      render: (a) => {
+        const viewports = opt(a.viewports, "1440,390").split(",").map((v) => Number(v.trim())).filter((n) => n > 0);
+        return `
+Import ${opt(a.url, "(ask me for the URL)")} into the connected Figma file.
+1. import_web {${/^https?:/.test(a.url ?? "") ? "url" : "path"}:"${opt(a.url, "<url>")}", viewports:${JSON.stringify(viewports)}}.
+2. For each frame, compare {nodeId: rootId, reference} and look at the regions with the largest mismatch: fix layout or spacing problems with run_script or build.
+3. Report fontSubstitutions: suggest installing the missing fonts or switching to the file's fonts.
+4. Rename layers that are still generic (Row, Column, Frame) after what they contain, and turn repeated cards or buttons into components if it helps.`;
+      }
+    },
+    {
+      name: "figma-to-code",
+      title: "Figma to code",
+      description: "Export a frame as code that uses the project's own components and tokens.",
+      args: { projectPath: "Root folder of the app (where package.json is)", target: "Layer name or id (default: the selection)" },
+      render: (a) => `
+Turn ${opt(a.target, "the selected frame")} into code for the project at ${opt(a.projectPath, "(ask me for the project folder)")}.
+1. export_code {projectPath, nodeId} without writing. Read the plan: the detected stack, the components used and the unmatched instances, the token sources.
+2. If important instances are unmatched, add figma-bridge.map.json entries for them (Figma component → code component and props) and export again.
+3. Review the code like a teammate would: semantics, accessibility (labels, alt text, buttons vs links), responsive behaviour. Fix names in Figma if class or component names are poor.
+4. When it looks right, export_code with write:true, then run the project's type-check or linter and fix what they report.`
+    },
+    {
+      name: "figma-to-roblox",
+      title: "Figma to Roblox",
+      description: "Turn a frame into Roblox UI and place it in Studio with a Roblox Studio MCP.",
+      args: { target: "Layer name or id (default: the selection)", mode: "scale, offset or hybrid (default hybrid)" },
+      render: (a) => `
+Turn ${opt(a.target, "the selected frame")} into Roblox UI that looks the same, and put it in the open Roblox Studio place.
+1. export_roblox {${a.target ? `nodeId:"<id of ${a.target}>", ` : ""}mode:"${opt(a.mode, "hybrid")}"}. Read the warnings (approximations, font substitutions).
+2. If assets are not uploaded (placeholders rbxassetid://PENDING_n): upload each file in assets[] with the Roblox Studio MCP (e.g. upload_image), and replace each placeholder in the Luau with the returned id.
+3. Run the Luau with execute_luau: it creates the ScreenGui under StarterGui (replacing an earlier copy) and returns it.
+4. Take a Studio screenshot and compare it with screenshot {returnImage:true} of the Figma frame. Fix differences in the Luau (or in Figma, then export again).
+5. Report the result and anything Roblox could not reproduce.`
+    },
+    {
+      name: "audit-and-fix",
+      title: "Audit and fix",
+      description: "Score the design system's health, apply safe fixes, and report what changed.",
+      args: { target: "Layer name or id to limit the fixes (default: the current page)" },
+      render: (a) => `
+Audit and improve this file${a.target ? ` (fixes limited to ${a.target})` : ""}.
+1. audit {scope:"design-system"} and summarize the score per category with the most important issues.
+2. checkpoint {action:"save"} on what you are going to change.
+3. audit {fix:true${a.target ? `, nodeId:"<id of ${a.target}>"` : ""}} and read the changes.
+4. Fix the remaining contrast errors and text without styles by hand where the right choice is clear; list the ones that need a design decision.
+5. audit {scope:"design-system"} again and report the score before and after.`
+    }
+  ];
+});
+
+// src/roblox/fonts.ts
+function robloxFamily(family, overrides = {}) {
+  const key = family.trim().toLowerCase();
+  const custom = Object.entries(overrides).find(([k]) => k.trim().toLowerCase() === key)?.[1];
+  const name = custom ?? ROBLOX_FONTS[key] ?? DEFAULT_FONT;
+  const url = /^rbxasset(id)?:\/\//.test(name) ? name : `rbxasset://fonts/families/${name.replace(/\s+/g, "")}.json`;
+  const exact = custom !== undefined || name.toLowerCase() === key.replace(/\s+/g, "") || key === "gotham" && name === "GothamSSm";
+  return { url, substituted: !exact };
+}
+function robloxWeight(weight) {
+  let best = WEIGHTS2[3];
+  for (const w of WEIGHTS2)
+    if (Math.abs(w[0] - weight) < Math.abs(best[0] - weight))
+      best = w;
+  return { value: best[0], name: best[1] };
+}
+var ROBLOX_FONTS, DEFAULT_FONT = "BuilderSans", WEIGHTS2;
+var init_fonts = __esm(() => {
+  ROBLOX_FONTS = {
+    "builder sans": "BuilderSans",
+    montserrat: "Montserrat",
+    roboto: "Roboto",
+    "roboto condensed": "RobotoCondensed",
+    "roboto mono": "RobotoMono",
+    "source sans pro": "SourceSansPro",
+    "source sans 3": "SourceSansPro",
+    nunito: "Nunito",
+    oswald: "Oswald",
+    merriweather: "Merriweather",
+    ubuntu: "Ubuntu",
+    "titillium web": "TitilliumWeb",
+    "press start 2p": "PressStart2P",
+    "fredoka one": "FredokaOne",
+    fredoka: "FredokaOne",
+    bangers: "Bangers",
+    creepster: "Creepster",
+    "luckiest guy": "LuckiestGuy",
+    "permanent marker": "PermanentMarker",
+    "patrick hand": "PatrickHand",
+    "indie flower": "IndieFlower",
+    "amatic sc": "AmaticSC",
+    kalam: "Kalam",
+    michroma: "Michroma",
+    jura: "Jura",
+    sarpanch: "Sarpanch",
+    "special elite": "SpecialElite",
+    "denk one": "DenkOne",
+    inconsolata: "Inconsolata",
+    arimo: "Arimo",
+    gotham: "GothamSSm",
+    "gotham ssm": "GothamSSm",
+    inter: "BuilderSans",
+    "sf pro": "BuilderSans",
+    "sf pro text": "BuilderSans",
+    "sf pro display": "BuilderSans",
+    "open sans": "BuilderSans",
+    lato: "BuilderSans",
+    poppins: "Montserrat",
+    "dm sans": "BuilderSans",
+    manrope: "BuilderSans",
+    "plus jakarta sans": "BuilderSans",
+    "work sans": "BuilderSans",
+    "ibm plex sans": "SourceSansPro",
+    arial: "Arimo",
+    helvetica: "Arimo",
+    "helvetica neue": "Arimo",
+    "segoe ui": "BuilderSans",
+    "jetbrains mono": "RobotoMono",
+    "fira code": "RobotoMono",
+    "source code pro": "RobotoMono",
+    "sf mono": "RobotoMono",
+    "courier new": "RobotoMono",
+    georgia: "Merriweather",
+    "times new roman": "Merriweather",
+    "playfair display": "Merriweather",
+    "bebas neue": "Oswald",
+    anton: "Oswald",
+    "comic sans ms": "PatrickHand"
+  };
+  WEIGHTS2 = [
+    [100, "Thin"],
+    [200, "ExtraLight"],
+    [300, "Light"],
+    [400, "Regular"],
+    [500, "Medium"],
+    [600, "SemiBold"],
+    [700, "Bold"],
+    [800, "ExtraBold"],
+    [900, "Heavy"]
+  ];
+});
+
+// src/roblox/map.ts
+function color3(hex) {
+  const h = hex.replace("#", "");
+  const c = (i) => num(parseInt(h.slice(i, i + 2), 16) / 255);
+  return { r: c(0), g: c(2), b: c(4) };
+}
+function visible(list) {
+  return (list ?? []).filter((p) => p.opacity > 0);
+}
+function decide(n, opts) {
+  const approximations = [];
+  if (n.text)
+    return { kind: "text", shadow: false, approximations };
+  const raster = opts.rasterize;
+  const fills = visible(n.fills);
+  const strokes = visible(n.strokes);
+  const effects = n.effects ?? [];
+  const drop = effects.filter((e) => e.type === "DROP_SHADOW");
+  const other = effects.filter((e) => e.type !== "DROP_SHADOW");
+  const hasChildren = !!n.children?.some((c) => !c.hidden);
+  if (n.vector || ["VECTOR", "BOOLEAN_OPERATION", "STAR", "POLYGON", "LINE"].includes(n.type)) {
+    return raster === "none" ? { kind: "frame", shadow: false, approximations: ["vector shape skipped (rasterize is none)"] } : { kind: "picture", shadow: false, approximations };
+  }
+  const image = fills.length === 1 && fills[0].type === "IMAGE";
+  if (image && !hasChildren && !strokes.length && !effects.length && raster !== "all")
+    return { kind: "image", shadow: false, approximations };
+  const reasons = [];
+  if (fills.length > 1)
+    reasons.push("several fills");
+  if (fills.length === 1 && !["SOLID", "GRADIENT_LINEAR", "IMAGE"].includes(fills[0].type))
+    reasons.push(`${fills[0].type.toLowerCase().replace("_", " ")} fill`);
+  if (image && (strokes.length || effects.length))
+    reasons.push("image with stroke or effects");
+  if (strokes.length > 1 || strokes[0] && strokes[0].type !== "SOLID")
+    reasons.push("complex stroke");
+  if (n.dashed)
+    reasons.push("dashed stroke");
+  if (other.length)
+    reasons.push(other.map((e) => e.type.toLowerCase().replace(/_/g, " ")).join(", "));
+  if (n.type === "ELLIPSE" && Math.abs(n.w - n.h) > 0.5)
+    reasons.push("oval");
+  const styled = fills.length + strokes.length + effects.length > 0;
+  if ((reasons.length || raster === "all" && styled) && raster !== "none") {
+    return { kind: hasChildren ? "panel" : "picture", shadow: false, approximations };
+  }
+  if (reasons.length)
+    approximations.push(`${reasons.join(", ")}: approximated (rasterize is none)`);
+  const r = n.radius ?? [];
+  if (r.length && r.some((v) => Math.abs(v - r[0]) > 0.5))
+    approximations.push("different corner radii: used the largest");
+  if (drop.length && raster === "none")
+    approximations.push("drop shadow skipped (rasterize is none)");
+  return { kind: "frame", shadow: drop.length > 0 && raster !== "none", approximations };
+}
+function pictureRequests(root, opts) {
+  const out = [];
+  const walk = (n) => {
+    if (n.hidden)
+      return;
+    const d = decide(n, opts);
+    if (d.kind === "picture")
+      out.push({ id: n.id, mode: "full" });
+    if (d.kind === "panel")
+      out.push({ id: n.id, mode: "panel" });
+    if (d.shadow)
+      out.push({ id: n.id, mode: "shadow" });
+    if (d.kind !== "picture")
+      for (const c of n.children ?? [])
+        walk(c);
+  };
+  walk(root);
+  return out;
+}
+function imageHashes(root) {
+  const out = new Set;
+  const walk = (n) => {
+    for (const f of n.fills ?? [])
+      if (f.imageHash)
+        out.add(f.imageHash);
+    for (const c of n.children ?? [])
+      walk(c);
+  };
+  walk(root);
+  return [...out];
+}
+
+class Mapper {
+  opts;
+  assets;
+  warnings = new Set;
+  fontSubstitutions = new Map;
+  counts = { instances: 0, pictures: 0, skippedHidden: 0 };
+  textFactor = 1;
+  constructor(opts, assets) {
+    this.opts = opts;
+    this.assets = assets;
+  }
+  warn(n, msg) {
+    if (this.warnings.size < 60)
+      this.warnings.add(n ? `${n.name}: ${msg}` : msg);
+  }
+  map(root) {
+    const [tw, th] = this.opts.targetResolution;
+    const fullScreen = Math.abs(root.w / root.h - tw / th) < 0.1 * (tw / th) && root.w >= tw * 0.4;
+    if (fullScreen && this.opts.mode !== "offset")
+      this.textFactor = tw / root.w;
+    const top = this.node(root, null, 0);
+    const geo = this.opts.mode === "offset" ? [["AnchorPoint", V2(0.5, 0.5)], ["Position", U2(0.5, 0, 0.5, 0)], ["Size", U2(0, root.w, 0, root.h)]] : fullScreen ? [["AnchorPoint", V2(0.5, 0.5)], ["Position", U2(0.5, 0, 0.5, 0)], ["Size", U2(1, 0, 1, 0)]] : [["AnchorPoint", V2(0.5, 0.5)], ["Position", U2(0.5, 0, 0.5, 0)], ["Size", U2(root.w / tw, 0, root.h / th, 0)]];
+    top.props = top.props.filter(([k]) => !["AnchorPoint", "Position", "Size", "LayoutOrder", "ZIndex"].includes(k));
+    top.props.splice(1, 0, ...geo);
+    top.children.push(this.inst("UIAspectRatioConstraint", "AspectRatio", [["AspectRatio", F(root.w / root.h)]]));
+    if (this.opts.asRootFrame)
+      return top;
+    return this.inst("ScreenGui", root.name, [["ResetOnSpawn", B(false)], ["ZIndexBehavior", E("ZIndexBehavior", "Sibling")], ["IgnoreGuiInset", B(true)]], [top]);
+  }
+  inst(className, name, props = [], children = [], source) {
+    this.counts.instances++;
+    return { className, name, props: [["Name", S(name)], ...props], children, ...source ? { source } : {} };
+  }
+  geometry(n, parent, index, d) {
+    const out = [];
+    if (!parent)
+      return out;
+    const inFlow = !!parent.layout && !n.absolute;
+    const useScale = this.opts.mode === "scale" || this.opts.mode === "hybrid" && !inFlow;
+    const hugW = n.sizing?.h === "HUG" && (d.kind === "text" || !!n.layout);
+    const hugH = n.sizing?.v === "HUG" && (d.kind === "text" || !!n.layout);
+    if (inFlow) {
+      const l = parent.layout;
+      const horizontal = l.mode === "HORIZONTAL";
+      const pw = parent.w - (l.padding[1] ?? 0) - (l.padding[3] ?? 0);
+      const ph = parent.h - (l.padding[0] ?? 0) - (l.padding[2] ?? 0);
+      const crossFill = horizontal ? n.sizing?.v === "FILL" || n.stretch : n.sizing?.h === "FILL" || n.stretch;
+      const w = (horizontal ? false : crossFill) ? U(1, 0) : hugW ? U(0, 0) : useScale && l.mode !== "GRID" ? U(n.w / Math.max(1, pw), 0) : U(0, n.w);
+      const h = (horizontal ? crossFill : false) ? U(1, 0) : hugH ? U(0, 0) : useScale && l.mode !== "GRID" ? U(n.h / Math.max(1, ph), 0) : U(0, n.h);
+      out.push(["Size", { t: "UDim2", xs: w.s, xo: w.o, ys: h.s, yo: h.o }]);
+      out.push(["LayoutOrder", I(index + 1)]);
+      return out;
+    }
+    const c = n.constraints ?? { h: "MIN", v: "MIN" };
+    const axis = (pos, size, total, k) => {
+      const end = total - pos - size;
+      if (k === "SCALE" || useScale) {
+        if (k === "MAX")
+          return { anchor: 1, p: [(pos + size) / total, 0], s: [size / total, 0] };
+        if (k === "CENTER")
+          return { anchor: 0.5, p: [(pos + size / 2) / total, 0], s: [size / total, 0] };
+        return { anchor: 0, p: [pos / total, 0], s: [size / total, 0] };
+      }
+      if (k === "MAX")
+        return { anchor: 1, p: [1, -end], s: [0, size] };
+      if (k === "CENTER")
+        return { anchor: 0.5, p: [0.5, pos + size / 2 - total / 2], s: [0, size] };
+      if (k === "STRETCH")
+        return { anchor: 0, p: [0, pos], s: [1, -(pos + end)] };
+      return { anchor: 0, p: [0, pos], s: [0, size] };
+    };
+    const x = axis(n.x, n.w, Math.max(1, parent.w), c.h);
+    const y = axis(n.y, n.h, Math.max(1, parent.h), c.v);
+    if (x.anchor || y.anchor)
+      out.push(["AnchorPoint", V2(x.anchor, y.anchor)]);
+    out.push(["Position", U2(x.p[0], x.p[1], y.p[0], y.p[1])]);
+    out.push(["Size", U2(hugW ? 0 : x.s[0], hugW ? 0 : x.s[1], hugH ? 0 : y.s[0], hugH ? 0 : y.s[1])]);
+    out.push(["ZIndex", I(index + 1)]);
+    return out;
+  }
+  automaticSize(n, d) {
+    const hugW = n.sizing?.h === "HUG" && (d.kind === "text" || !!n.layout);
+    const hugH = n.sizing?.v === "HUG" && (d.kind === "text" || !!n.layout);
+    if (!hugW && !hugH)
+      return [];
+    return [["AutomaticSize", E("AutomaticSize", hugW && hugH ? "XY" : hugW ? "X" : "Y")]];
+  }
+  corner(n) {
+    const r = Math.max(0, ...n.radius ?? []);
+    if (!r && !(n.type === "ELLIPSE"))
+      return null;
+    const pill = n.type === "ELLIPSE" || r >= Math.min(n.w, n.h) / 2 - 0.5;
+    return this.inst("UICorner", "UICorner", [["CornerRadius", pill ? U(0.5, 0) : U(0, r)]]);
+  }
+  stroke(n) {
+    const s = visible(n.strokes)[0];
+    if (!s || s.type !== "SOLID" || !n.strokeWeight)
+      return null;
+    return this.inst("UIStroke", "UIStroke", [
+      ["ApplyStrokeMode", E("ApplyStrokeMode", "Border")],
+      ["Color", C3(s.color)],
+      ["Thickness", F(n.strokeWeight)],
+      ["Transparency", F(1 - s.opacity)],
+      ["LineJoinMode", E("LineJoinMode", "Round")]
+    ]);
+  }
+  gradient(p) {
+    let stops = [...p.stops ?? []].sort((a, b) => a.at - b.at);
+    if (stops.length > 20) {
+      this.warn(null, "a gradient has more than 20 stops: kept 20");
+      stops = stops.filter((_, i) => i % Math.ceil(stops.length / 20) === 0);
+    }
+    if (stops[0].at > 0)
+      stops.unshift({ ...stops[0], at: 0 });
+    if (stops[stops.length - 1].at < 1)
+      stops.push({ ...stops[stops.length - 1], at: 1 });
+    stops[0] = { ...stops[0], at: 0 };
+    stops[stops.length - 1] = { ...stops[stops.length - 1], at: 1 };
+    return this.inst("UIGradient", "UIGradient", [
+      ["Color", { t: "ColorSequence", keys: stops.map((s) => ({ time: num(s.at), ...color3(s.color) })) }],
+      ["Transparency", { t: "NumberSequence", keys: stops.map((s) => ({ time: num(s.at), value: num(1 - s.alpha * p.opacity) })) }],
+      ["Rotation", F(p.angle ?? 0)]
+    ]);
+  }
+  layoutChildren(n) {
+    const l = n.layout;
+    const out = [];
+    const [t, r, b, lft] = l.padding;
+    if (t || r || b || lft)
+      out.push(this.inst("UIPadding", "UIPadding", [["PaddingTop", U(0, t)], ["PaddingRight", U(0, r)], ["PaddingBottom", U(0, b)], ["PaddingLeft", U(0, lft)]]));
+    if (l.mode === "GRID") {
+      const kids = (n.children ?? []).filter((c) => !c.hidden && !c.absolute);
+      const first = kids[0];
+      if (kids.some((k) => Math.abs(k.w - (first?.w ?? 0)) > 1 || Math.abs(k.h - (first?.h ?? 0)) > 1))
+        this.warn(n, "grid cells of different sizes: UIGridLayout uses the first cell's size");
+      out.push(this.inst("UIGridLayout", "UIGridLayout", [
+        ["CellSize", U2(0, first?.w ?? 100, 0, first?.h ?? 100)],
+        ["CellPadding", U2(0, l.columnGap ?? 0, 0, l.rowGap ?? 0)],
+        ["FillDirectionMaxCells", I(l.columns ?? 0)],
+        ["SortOrder", E("SortOrder", "LayoutOrder")]
+      ]));
+      return out;
+    }
+    const horizontal = l.mode === "HORIZONTAL";
+    const main = l.primary === "CENTER" ? "Center" : l.primary === "MAX" ? horizontal ? "Right" : "Bottom" : horizontal ? "Left" : "Top";
+    const cross = l.counter === "CENTER" ? "Center" : l.counter === "MAX" ? horizontal ? "Bottom" : "Right" : horizontal ? "Top" : "Left";
+    const props = [
+      ["FillDirection", E("FillDirection", horizontal ? "Horizontal" : "Vertical")],
+      ["SortOrder", E("SortOrder", "LayoutOrder")],
+      ["Padding", U(0, l.primary === "SPACE_BETWEEN" ? 0 : l.gap)],
+      ["HorizontalAlignment", E("HorizontalAlignment", horizontal ? main === "Right" ? "Right" : main === "Center" ? "Center" : "Left" : cross === "Right" ? "Right" : cross === "Center" ? "Center" : "Left")],
+      ["VerticalAlignment", E("VerticalAlignment", horizontal ? cross === "Bottom" ? "Bottom" : cross === "Center" ? "Center" : "Top" : main === "Bottom" ? "Bottom" : main === "Center" ? "Center" : "Top")]
+    ];
+    if (l.primary === "SPACE_BETWEEN")
+      props.push([horizontal ? "HorizontalFlex" : "VerticalFlex", E("UIFlexAlignment", "SpaceBetween")]);
+    if (l.wrap)
+      props.push(["Wraps", B(true)]);
+    if (l.counter === "BASELINE")
+      this.warn(n, "baseline alignment: aligned to the top");
+    out.push(this.inst("UIListLayout", "UIListLayout", props));
+    return out;
+  }
+  assetUrl(key, n) {
+    const a = this.assets(key);
+    if (!a) {
+      this.warn(n, "picture missing: left empty");
+      return { url: "" };
+    }
+    return a;
+  }
+  textProps(n) {
+    const t = n.text;
+    const segs = t.segments.length ? t.segments : [{ text: t.characters, family: "Inter", style: "Regular", weight: 400, size: 14 }];
+    const base = segs.reduce((a, s) => s.text.length > a.text.length ? s : a, segs[0]);
+    const family = robloxFamily(base.family, this.opts.fonts);
+    if (family.substituted)
+      this.fontSubstitutions.set(base.family, family.url.replace(/^.*\/(\w+)\.json$/, "$1"));
+    const weight = robloxWeight(base.weight);
+    const italic = /italic|oblique/i.test(base.style);
+    const size = Math.max(1, Math.round(base.size * this.textFactor));
+    const props = [
+      ["BackgroundTransparency", F(1)],
+      ["FontFace", { t: "Font", family: family.url, weight: weight.value, weightName: weight.name, style: italic ? "Italic" : "Normal" }],
+      ["TextSize", I(size)],
+      ["TextColor3", C3(base.color ?? "#000000")]
+    ];
+    const alpha = (base.alpha ?? 1) * (n.opacity ?? 1);
+    if (alpha < 1)
+      props.push(["TextTransparency", F(1 - alpha)]);
+    const rich = segs.length > 1 && segs.some((s) => s.color !== base.color || s.weight !== base.weight || s.size !== base.size || s.family !== base.family || s.decoration || s.textCase || /italic/i.test(s.style) !== italic);
+    const text = segs.map((s) => s.text).join("");
+    if (rich) {
+      props.push(["RichText", B(true)], ["Text", S(segs.map((s) => this.richRun(s, base)).join(""))]);
+    } else {
+      let value = text;
+      if (base.textCase === "UPPER")
+        value = value.toUpperCase();
+      else if (base.textCase === "LOWER")
+        value = value.toLowerCase();
+      if (base.decoration)
+        props.push(["RichText", B(true)], ["Text", S(this.richRun({ ...base, text: value, textCase: undefined }, { ...base, decoration: undefined }))]);
+      else
+        props.push(["Text", S(value)]);
+    }
+    props.push(["TextXAlignment", E("TextXAlignment", t.align === "CENTER" ? "Center" : t.align === "RIGHT" ? "Right" : "Left")]);
+    props.push(["TextYAlignment", E("TextYAlignment", t.valign === "CENTER" ? "Center" : t.valign === "BOTTOM" ? "Bottom" : "Top")]);
+    if (t.autoResize !== "WIDTH_AND_HEIGHT")
+      props.push(["TextWrapped", B(true)]);
+    if (base.lineHeight)
+      props.push(["LineHeight", F(Math.max(1, Math.min(3, base.lineHeight / (base.size * 1.2))))]);
+    if (t.maxLines)
+      props.push(["TextTruncate", E("TextTruncate", "AtEnd")]);
+    if (this.opts.textScaled)
+      props.push(["TextScaled", B(true)]);
+    if (segs.some((s) => s.letterSpacing))
+      this.warn(n, "letter spacing has no Roblox equivalent: ignored");
+    return props;
+  }
+  richRun(s, base) {
+    let text = s.text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+    const attrs = [];
+    if (s.color && s.color !== base.color)
+      attrs.push(`color="${s.color}"`);
+    if (s.size !== base.size)
+      attrs.push(`size="${Math.round(s.size * this.textFactor)}"`);
+    if (s.weight !== base.weight)
+      attrs.push(`weight="${robloxWeight(s.weight).value}"`);
+    if (s.family !== base.family)
+      attrs.push(`family="${robloxFamily(s.family, this.opts.fonts).url}"`);
+    if (s.alpha !== undefined && s.alpha < 1)
+      attrs.push(`transparency="${num(1 - s.alpha)}"`);
+    if (attrs.length)
+      text = `<font ${attrs.join(" ")}>${text}</font>`;
+    if (/italic/i.test(s.style) && !/italic/i.test(base.style))
+      text = `<i>${text}</i>`;
+    if (s.decoration === "UNDERLINE")
+      text = `<u>${text}</u>`;
+    if (s.decoration === "STRIKETHROUGH")
+      text = `<s>${text}</s>`;
+    if (s.textCase === "UPPER")
+      text = `<uc>${text}</uc>`;
+    if (s.textCase === "SMALL_CAPS" || s.textCase === "SMALL_CAPS_FORCED")
+      text = `<sc>${text}</sc>`;
+    return text;
+  }
+  node(n, parent, index) {
+    if (n.hidden) {
+      this.counts.skippedHidden++;
+      return null;
+    }
+    const d = decide(n, this.opts);
+    for (const a of d.approximations)
+      this.warn(n, a);
+    const button = !!parent && (n.clickable || BUTTON_NAME.test(n.name)) && d.kind !== "text";
+    const geo = this.geometry(n, parent, index, d);
+    const common = [...geo, ...this.automaticSize(n, d)];
+    if (n.rotation)
+      common.push(["Rotation", F(n.rotation)]);
+    const children = [];
+    let className = "Frame";
+    let props = [];
+    if (d.kind === "text") {
+      className = n.clickable || BUTTON_NAME.test(n.name) ? "TextButton" : "TextLabel";
+      props = this.textProps(n);
+      if (className === "TextButton")
+        props.push(["AutoButtonColor", B(false)]);
+      const size = props.find(([k]) => k === "TextSize")[1].v;
+      children.push(this.inst("UITextSizeConstraint", "UITextSizeConstraint", [["MaxTextSize", I(size)], ["MinTextSize", I(Math.max(1, Math.round(size * 0.5)))]]));
+      return this.inst(className, n.name, [...common, ...props], children, n.id);
+    }
+    if (d.kind === "picture") {
+      this.counts.pictures++;
+      const a = this.assetUrl(`${n.id}:full`, n);
+      className = button ? "ImageButton" : "ImageLabel";
+      const pic = this.pictureGeometry(n, a, geo);
+      props = [["BackgroundTransparency", F(1)], ["Image", { t: "Content", url: a.url }], ["ScaleType", E("ScaleType", "Stretch")]];
+      if (n.opacity !== undefined && n.opacity < 1)
+        props.push(["ImageTransparency", F(1 - n.opacity)]);
+      if (button)
+        props.push(["AutoButtonColor", B(false)]);
+      children.push(this.inst("UIAspectRatioConstraint", "UIAspectRatioConstraint", [["AspectRatio", F((a.size?.w ?? n.w) / Math.max(1, a.size?.h ?? n.h))]]));
+      return this.inst(className, n.name, [...pic, ...props], children, n.id);
+    }
+    const fills = visible(n.fills);
+    const opacity = n.opacity ?? 1;
+    const hasKids = !!n.children?.some((c) => !c.hidden);
+    if (d.kind === "image") {
+      const f = fills[0];
+      const a = this.assetUrl(`image:${f.imageHash}`, n);
+      className = button ? "ImageButton" : "ImageLabel";
+      const scaleType = f.scaleMode === "FIT" ? "Fit" : f.scaleMode === "TILE" ? "Tile" : "Crop";
+      props = [["BackgroundTransparency", F(1)], ["Image", { t: "Content", url: a.url }], ["ScaleType", E("ScaleType", scaleType)]];
+      if (f.opacity * opacity < 1)
+        props.push(["ImageTransparency", F(1 - f.opacity * opacity)]);
+      if (button)
+        props.push(["AutoButtonColor", B(false)]);
+      const corner = this.corner(n);
+      if (corner)
+        children.push(corner);
+      children.push(this.inst("UIAspectRatioConstraint", "UIAspectRatioConstraint", [["AspectRatio", F(n.w / Math.max(1, n.h))]]));
+      return this.inst(className, n.name, [...common, ...props], children, n.id);
+    }
+    if (d.kind === "panel") {
+      this.counts.pictures++;
+      const a = this.assetUrl(`${n.id}:panel`, n);
+      const scale = this.opts.scale ?? 2;
+      const inset = Math.ceil((Math.max(0, ...n.radius ?? [0]) + (n.strokeWeight ?? 0) + 2) * scale);
+      const pw = Math.round((a.size?.w ?? n.w) * scale);
+      const ph = Math.round((a.size?.h ?? n.h) * scale);
+      const ix = Math.min(inset, Math.floor(pw / 2) - 1);
+      const iy = Math.min(inset, Math.floor(ph / 2) - 1);
+      className = button ? "ImageButton" : "ImageLabel";
+      props = [
+        ["BackgroundTransparency", F(1)],
+        ["Image", { t: "Content", url: a.url }],
+        ["ScaleType", E("ScaleType", "Slice")],
+        ["SliceCenter", { t: "Rect", x0: ix, y0: iy, x1: pw - ix, y1: ph - iy }],
+        ["SliceScale", F(1 / scale)]
+      ];
+      if (opacity < 1)
+        props.push(["ImageTransparency", F(1 - opacity)]);
+      if (button)
+        props.push(["AutoButtonColor", B(false)]);
+    } else {
+      className = button ? "TextButton" : hasKids && opacity < 1 ? "CanvasGroup" : "Frame";
+      const f = fills[0];
+      if (!f)
+        props.push(["BackgroundTransparency", F(1)]);
+      else if (f.type === "SOLID") {
+        props.push(["BackgroundColor3", C3(f.color)]);
+        const t = 1 - f.opacity * (className === "CanvasGroup" ? 1 : opacity);
+        if (t > 0)
+          props.push(["BackgroundTransparency", F(t)]);
+      } else if (f.type === "GRADIENT_LINEAR") {
+        props.push(["BackgroundColor3", C3("#FFFFFF")]);
+        children.push(this.gradient(f));
+      } else if (f.type === "IMAGE") {
+        props.push(["BackgroundTransparency", F(1)]);
+        const a = this.assetUrl(`image:${f.imageHash}`, n);
+        const bg = this.inst("ImageLabel", "Background", [["Size", U2(1, 0, 1, 0)], ["ZIndex", I(0)], ["BackgroundTransparency", F(1)], ["Image", { t: "Content", url: a.url }], ["ScaleType", E("ScaleType", f.scaleMode === "FIT" ? "Fit" : "Crop")]]);
+        const corner = this.corner(n);
+        if (corner)
+          bg.children.push(corner);
+        children.push(bg);
+      }
+      if (className === "CanvasGroup")
+        props.push(["GroupTransparency", F(1 - opacity)]);
+      if (button)
+        props.push(["Text", S("")], ["AutoButtonColor", B(false)]);
+      const corner = this.corner(n);
+      if (corner)
+        children.push(corner);
+      const stroke = this.stroke(n);
+      if (stroke)
+        children.push(stroke);
+    }
+    props.push(["BorderSizePixel", I(0)]);
+    if (n.clip)
+      props.push(["ClipsDescendants", B(true)]);
+    const kids = n.children ?? [];
+    const flow = n.layout ? kids.filter((k) => !k.absolute) : kids;
+    const loose = n.layout ? kids.filter((k) => k.absolute) : [];
+    const me = { w: n.w, h: n.h, layout: n.layout };
+    const mapped = (list, p) => list.map((k, i) => this.node(k, p, i)).filter((x) => !!x);
+    const flowMapped = mapped(flow, me);
+    if (n.layout && n.layout.mode !== "GRID") {
+      for (const k of flow) {
+        const target = k.grow && !k.hidden ? flowMapped.find((c) => c.source === k.id) : undefined;
+        if (target)
+          target.children.push(this.inst("UIFlexItem", "UIFlexItem", [["FlexMode", E("UIFlexMode", "Fill")]]));
+      }
+    }
+    if (n.layout && loose.length) {
+      const contentZ = kids.findIndex((k) => !k.absolute) + 1;
+      const content = this.inst("Frame", "Content", [["Size", U2(1, 0, 1, 0)], ["ZIndex", I(contentZ)], ["BackgroundTransparency", F(1)], ["BorderSizePixel", I(0)]], [...this.layoutChildren(n), ...flowMapped]);
+      const overlay = loose.map((k) => this.node(k, { w: n.w, h: n.h }, kids.indexOf(k))).filter((x) => !!x);
+      children.push(content, ...overlay);
+    } else {
+      if (n.layout)
+        children.push(...this.layoutChildren(n));
+      children.push(...flowMapped);
+    }
+    const self = this.inst(className, n.name, [...common, ...props], children, n.id);
+    if (!d.shadow)
+      return self;
+    this.counts.pictures++;
+    const a = this.assetUrl(`${n.id}:shadow`, n);
+    const scale = this.opts.scale ?? 2;
+    const sh = (n.effects ?? []).filter((e) => e.type === "DROP_SHADOW");
+    const reach = Math.max(...sh.map((e) => e.blur + (e.spread ?? 0) + Math.max(Math.abs(e.x ?? 0), Math.abs(e.y ?? 0))));
+    const off = a.offset ?? { x: 0, y: 0 };
+    const size = a.size ?? { w: n.w, h: n.h };
+    const inset = Math.ceil((Math.max(0, ...n.radius ?? [0]) + reach) * scale);
+    const pw = Math.round(size.w * scale);
+    const ph = Math.round(size.h * scale);
+    const ix = Math.min(inset, Math.floor(pw / 2) - 1);
+    const iy = Math.min(inset, Math.floor(ph / 2) - 1);
+    const shadow = this.inst("ImageLabel", "Shadow", [
+      ["Position", U2(0, off.x, 0, off.y)],
+      ["Size", U2(1, size.w - n.w, 1, size.h - n.h)],
+      ["ZIndex", I(1)],
+      ["BackgroundTransparency", F(1)],
+      ["Image", { t: "Content", url: a.url }],
+      ["ScaleType", E("ScaleType", "Slice")],
+      ["SliceCenter", { t: "Rect", x0: ix, y0: iy, x1: pw - ix, y1: ph - iy }],
+      ["SliceScale", F(1 / scale)]
+    ]);
+    self.props = self.props.filter(([k]) => !["AnchorPoint", "Position", "Size", "LayoutOrder", "AutomaticSize"].includes(k));
+    self.props.splice(1, 0, ["Size", U2(1, 0, 1, 0)], ["ZIndex", I(2)]);
+    return this.inst("Frame", n.name, [...common.filter(([k]) => k !== "AutomaticSize"), ["BackgroundTransparency", F(1)], ["BorderSizePixel", I(0)]], [shadow, self], n.id);
+  }
+  pictureGeometry(n, a, geo) {
+    if (!a.offset || !a.size || Math.abs(a.offset.x) < 0.5 && Math.abs(a.offset.y) < 0.5 && Math.abs(a.size.w - n.w) < 0.5 && Math.abs(a.size.h - n.h) < 0.5)
+      return geo;
+    return geo.map(([k, v]) => {
+      if (k === "Size" && v.t === "UDim2")
+        return [k, { ...v, xo: Math.round(v.xo + a.size.w - n.w), yo: Math.round(v.yo + a.size.h - n.h) }];
+      if (k === "Position" && v.t === "UDim2")
+        return [k, { ...v, xo: Math.round(v.xo + a.offset.x), yo: Math.round(v.yo + a.offset.y) }];
+      return [k, v];
+    });
+  }
+}
+function mapToRoblox(root, opts, assets) {
+  const m = new Mapper(opts, assets);
+  const out = m.map(root);
+  if (m.counts.skippedHidden)
+    m.warn(null, `${m.counts.skippedHidden} hidden layer(s) skipped`);
+  return { root: out, warnings: [...m.warnings], fontSubstitutions: Object.fromEntries(m.fontSubstitutions), counts: m.counts };
+}
+var num = (v) => Math.round(v * 1000) / 1000, S = (v) => ({ t: "string", v }), B = (v) => ({ t: "bool", v }), I = (v) => ({ t: "int", v: Math.round(v) }), F = (v) => ({ t: "float", v: num(v) }), E = (e, v) => ({ t: "enum", e, v }), U = (s, o) => ({ t: "UDim", s: num(s), o: Math.round(o) }), U2 = (xs, xo, ys, yo) => ({ t: "UDim2", xs: num(xs), xo: Math.round(xo), ys: num(ys), yo: Math.round(yo) }), V2 = (x, y) => ({ t: "Vector2", x: num(x), y: num(y) }), C3 = (hex) => ({ t: "Color3", ...color3(hex) }), BUTTON_NAME;
+var init_map2 = __esm(() => {
+  init_fonts();
+  BUTTON_NAME = /\b(button|btn|cta)\b/i;
+});
+
+// src/roblox/output.ts
+function xmlProp(name, v) {
+  switch (v.t) {
+    case "string":
+      return `<string name="${name}">${xml(v.v)}</string>`;
+    case "bool":
+      return `<bool name="${name}">${v.v}</bool>`;
+    case "int":
+      return `<int name="${name}">${v.v}</int>`;
+    case "float":
+      return `<float name="${name}">${n(v.v)}</float>`;
+    case "Color3":
+      return `<Color3 name="${name}"><R>${n(v.r)}</R><G>${n(v.g)}</G><B>${n(v.b)}</B></Color3>`;
+    case "UDim":
+      return `<UDim name="${name}"><S>${n(v.s)}</S><O>${v.o}</O></UDim>`;
+    case "UDim2":
+      return `<UDim2 name="${name}"><XS>${n(v.xs)}</XS><XO>${v.xo}</XO><YS>${n(v.ys)}</YS><YO>${v.yo}</YO></UDim2>`;
+    case "Vector2":
+      return `<Vector2 name="${name}"><X>${n(v.x)}</X><Y>${n(v.y)}</Y></Vector2>`;
+    case "Rect":
+      return `<Rect2D name="${name}"><min><X>${n(v.x0)}</X><Y>${n(v.y0)}</Y></min><max><X>${n(v.x1)}</X><Y>${n(v.y1)}</Y></max></Rect2D>`;
+    case "enum": {
+      const value = ENUMS[v.e]?.[v.v];
+      if (value === undefined)
+        throw new Error(`No enum value for ${v.e}.${v.v}`);
+      return `<token name="${name}">${value}</token>`;
+    }
+    case "Content":
+      return v.url ? `<Content name="${name}"><url>${xml(v.url)}</url></Content>` : `<Content name="${name}"><null></null></Content>`;
+    case "ColorSequence":
+      return `<ColorSequence name="${name}">${v.keys.map((k) => `${n(k.time)} ${n(k.r)} ${n(k.g)} ${n(k.b)} 0 `).join("")}</ColorSequence>`;
+    case "NumberSequence":
+      return `<NumberSequence name="${name}">${v.keys.map((k) => `${n(k.time)} ${n(k.value)} 0 `).join("")}</NumberSequence>`;
+    case "Font":
+      return `<Font name="${name}"><Family><url>${xml(v.family)}</url></Family><Weight>${v.weight}</Weight><Style>${v.style}</Style></Font>`;
+  }
+}
+function toRbxmx(root) {
+  let ref = 0;
+  const item = (i, depth) => {
+    const pad = "\t".repeat(depth);
+    const props = i.props.map(([k, v]) => `${pad}		${xmlProp(k, v)}`).join(`
+`);
+    const kids = i.children.map((c) => item(c, depth + 1)).join(`
+`);
+    return `${pad}<Item class="${i.className}" referent="RBX${(ref++).toString(16).toUpperCase().padStart(8, "0")}">
+${pad}	<Properties>
+${props}
+${pad}	</Properties>${kids ? `
+${kids}` : ""}
+${pad}</Item>`;
+  };
+  return `<roblox xmlns:xmime="http://www.w3.org/2005/05/xmlmime" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.roblox.com/roblox.xsd" version="4">
+` + `	<External>null</External>
+	<External>nil</External>
+` + item(root, 1) + `
+</roblox>
+`;
+}
+function luauString(s) {
+  return `"${s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, (c) => `\\${c.charCodeAt(0)}`)}"`;
+}
+function luauValue(v) {
+  switch (v.t) {
+    case "string":
+      return luauString(v.v);
+    case "bool":
+      return String(v.v);
+    case "int":
+      return String(v.v);
+    case "float":
+      return n(v.v);
+    case "Color3":
+      return `Color3.fromRGB(${rgb(v.r)}, ${rgb(v.g)}, ${rgb(v.b)})`;
+    case "UDim":
+      return `UDim.new(${n(v.s)}, ${v.o})`;
+    case "UDim2":
+      if (!v.xo && !v.yo)
+        return `UDim2.fromScale(${n(v.xs)}, ${n(v.ys)})`;
+      if (!v.xs && !v.ys)
+        return `UDim2.fromOffset(${v.xo}, ${v.yo})`;
+      return `UDim2.new(${n(v.xs)}, ${v.xo}, ${n(v.ys)}, ${v.yo})`;
+    case "Vector2":
+      return `Vector2.new(${n(v.x)}, ${n(v.y)})`;
+    case "Rect":
+      return `Rect.new(${n(v.x0)}, ${n(v.y0)}, ${n(v.x1)}, ${n(v.y1)})`;
+    case "enum":
+      return `Enum.${v.e}.${v.v}`;
+    case "Content":
+      return luauString(v.url);
+    case "ColorSequence":
+      return `ColorSequence.new({
+${v.keys.map((k) => `		ColorSequenceKeypoint.new(${n(k.time)}, Color3.fromRGB(${rgb(k.r)}, ${rgb(k.g)}, ${rgb(k.b)})),`).join(`
+`)}
+	})`;
+    case "NumberSequence":
+      return `NumberSequence.new({
+${v.keys.map((k) => `		NumberSequenceKeypoint.new(${n(k.time)}, ${n(k.value)}),`).join(`
+`)}
+	})`;
+    case "Font":
+      return `Font.new(${luauString(v.family)}, Enum.FontWeight.${v.weightName}, Enum.FontStyle.${v.style})`;
+  }
+}
+function identifier(name, className, used) {
+  const words = name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).slice(0, 5);
+  let id = words.map((w, i) => i ? w[0].toUpperCase() + w.slice(1).toLowerCase() : w.toLowerCase()).join("");
+  if (!id || /^\d/.test(id))
+    id = className[0].toLowerCase() + className.slice(1) + (id ? id[0].toUpperCase() + id.slice(1) : "");
+  if (KEYWORDS.has(id))
+    id += "Gui";
+  let unique = id;
+  for (let k = 2;used.has(unique); k++)
+    unique = `${id}${k}`;
+  used.add(unique);
+  return unique;
+}
+function toLuau(root, opts = {}) {
+  const used = new Set;
+  const lines = [];
+  const emit = (i, parentVar, depth) => {
+    const v = identifier(i.name, i.className, used);
+    if (!/^UI/.test(i.className) && depth <= 2 && parentVar)
+      lines.push("", `-- ${i.name.replace(/\n/g, " ")}`);
+    lines.push(`local ${v} = Instance.new(${luauString(i.className)})`);
+    for (const [k, val] of i.props)
+      lines.push(`${v}.${k} = ${luauValue(val)}`);
+    for (const c of i.children)
+      emit(c, v, depth + 1);
+    if (parentVar)
+      lines.push(`${v}.Parent = ${parentVar}`);
+    return v;
+  };
+  const header = [
+    `-- ${root.name}: generated by Figma Bridge${opts.source ? ` from "${opts.source.replace(/\n/g, " ")}"` : ""} (export_roblox).`,
+    "-- Creates the UI under PARENT and returns it. Running it again replaces the previous copy.",
+    `local PARENT = ${opts.parent ?? 'game:GetService("StarterGui")'}`,
+    "",
+    `local existing = PARENT:FindFirstChild(${luauString(root.name)})`,
+    "if existing then",
+    "\texisting:Destroy()",
+    "end",
+    ""
+  ];
+  const rootVar = emit(root, null, 0);
+  return `${header.join(`
+`)}
+${lines.join(`
+`)}
+
+${rootVar}.Parent = PARENT
+return ${rootVar}
+`.replace(/\n{3,}/g, `
+
+`);
+}
+function substituteAssets(text, ids) {
+  return text.replace(/rbxassetid:\/\/PENDING_\d+/g, (m) => ids[m] ? `rbxassetid://${ids[m]}` : m);
+}
+var ENUMS, n = (v) => String(Math.round(v * 1000) / 1000), xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"), KEYWORDS, rgb = (v) => Math.round(v * 255);
+var init_output = __esm(() => {
+  ENUMS = {
+    ZIndexBehavior: { Global: 0, Sibling: 1 },
+    FillDirection: { Horizontal: 0, Vertical: 1 },
+    HorizontalAlignment: { Center: 0, Left: 1, Right: 2 },
+    VerticalAlignment: { Center: 0, Top: 1, Bottom: 2 },
+    SortOrder: { Name: 0, Custom: 1, LayoutOrder: 2 },
+    UIFlexAlignment: { None: 0, Fill: 1, SpaceAround: 2, SpaceBetween: 3, SpaceEvenly: 4 },
+    UIFlexMode: { None: 0, Grow: 1, Shrink: 2, Fill: 3, Custom: 4 },
+    AutomaticSize: { None: 0, X: 1, Y: 2, XY: 3 },
+    TextXAlignment: { Left: 0, Right: 1, Center: 2 },
+    TextYAlignment: { Top: 0, Center: 1, Bottom: 2 },
+    ScaleType: { Stretch: 0, Slice: 1, Tile: 2, Fit: 3, Crop: 4 },
+    ApplyStrokeMode: { Contextual: 0, Border: 1 },
+    LineJoinMode: { Round: 0, Bevel: 1, Miter: 2 },
+    TextTruncate: { None: 0, AtEnd: 1, SplitWord: 2 }
+  };
+  KEYWORDS = new Set(["and", "break", "do", "else", "elseif", "end", "false", "for", "function", "if", "in", "local", "nil", "not", "or", "repeat", "return", "then", "true", "until", "while", "continue", "export", "type", "game", "workspace", "script", "PARENT", "existing"]);
+});
+
+// src/roblox/upload.ts
+import { createHash } from "node:crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+function creatorFrom(id) {
+  const m = /^(?:(user|group)[:/])?\s*(\d+)$/i.exec(id.trim());
+  if (!m)
+    throw new RobloxUploadError(`ROBLOX_CREATOR_ID must be a user id, "user:<id>" or "group:<id>", not "${id}".`, "BAD_CREATOR");
+  return m[1]?.toLowerCase() === "group" ? { groupId: m[2] } : { userId: m[2] };
+}
+
+class RobloxUploader {
+  opts;
+  cache = {};
+  fetchImpl;
+  sleep;
+  base;
+  constructor(opts) {
+    this.opts = opts;
+    this.fetchImpl = opts.fetchImpl ?? fetch;
+    this.sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    this.base = opts.base ?? process.env.ROBLOX_API_URL ?? "https://apis.roblox.com";
+    try {
+      this.cache = JSON.parse(readFileSync2(opts.cacheFile, "utf8"));
+    } catch {}
+  }
+  static hash(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+  }
+  async request(url, init) {
+    let delay = 1000;
+    for (let attempt = 0;; attempt++) {
+      const res = await this.fetchImpl(url, { ...init, headers: { ...init.headers, "x-api-key": this.opts.apiKey }, signal: AbortSignal.timeout(60000) });
+      if (res.ok)
+        return res.json();
+      const retryAfter = Number(res.headers.get("retry-after"));
+      if ((res.status === 429 || res.status >= 500) && attempt < 3) {
+        await this.sleep(retryAfter > 0 ? retryAfter * 1000 : delay);
+        delay *= 2;
+        continue;
+      }
+      let detail = "";
+      try {
+        const body = await res.json();
+        detail = body.message ?? body.errors?.[0]?.message ?? "";
+      } catch {}
+      if (res.status === 401 || res.status === 403)
+        throw new RobloxUploadError(`Roblox refused the API key (${res.status}${detail ? `: ${detail}` : ""}). It needs the Assets API with Read and Write, for this creator.`, "FORBIDDEN");
+      throw new RobloxUploadError(`Roblox Open Cloud error ${res.status}${detail ? `: ${detail}` : ""}`, "UPLOAD_FAILED");
+    }
+  }
+  async upload(bytes, name) {
+    const hash = RobloxUploader.hash(bytes);
+    if (this.cache[hash])
+      return { assetId: this.cache[hash], cached: true };
+    const form = new FormData;
+    form.append("request", JSON.stringify({
+      assetType: "Image",
+      displayName: name.slice(0, 50) || "Figma Bridge image",
+      description: "Uploaded by Figma Bridge (export_roblox)",
+      creationContext: { creator: creatorFrom(this.opts.creatorId) }
+    }));
+    form.append("fileContent", new Blob([new Uint8Array(bytes)], { type: "image/png" }), `${name.replace(/[^\w.-]+/g, "_") || "image"}.png`);
+    let op = await this.request(`${this.base}/assets/v1/assets`, { method: "POST", body: form });
+    for (let i = 0;!op.done; i++) {
+      if (i >= 20)
+        throw new RobloxUploadError(`Roblox is still processing "${name}": try again in a minute.`, "UPLOAD_PENDING");
+      await this.sleep(Math.min(500 * 2 ** i, 4000));
+      const id = String(op.operationId ?? op.path ?? "").replace(/^operations\//, "");
+      if (!id)
+        throw new RobloxUploadError("Roblox returned no operation to wait for.", "UPLOAD_FAILED");
+      op = await this.request(`${this.base}/assets/v1/operations/${id}`, { method: "GET" });
+    }
+    const assetId = String(op.response?.assetId ?? "");
+    if (!assetId)
+      throw new RobloxUploadError(`Upload of "${name}" finished without an asset id${op.error?.message ? `: ${op.error.message}` : ""}.`, "UPLOAD_FAILED");
+    this.cache[hash] = assetId;
+    mkdirSync2(dirname2(this.opts.cacheFile), { recursive: true });
+    writeFileSync2(this.opts.cacheFile, JSON.stringify(this.cache, null, 2));
+    return { assetId, cached: false };
+  }
+}
+var RobloxUploadError, UPLOAD_HELP;
+var init_upload = __esm(() => {
+  RobloxUploadError = class RobloxUploadError extends Error {
+    code;
+    constructor(message, code) {
+      super(message);
+      this.code = code;
+    }
+  };
+  UPLOAD_HELP = "To upload pictures automatically, create an Open Cloud API key at create.roblox.com → Open Cloud → API Keys with the " + "Assets API (Read and Write) and your experience's creator, then set ROBLOX_API_KEY and ROBLOX_CREATOR_ID (your user id, " + 'or "group:<id>") in the Figma Bridge env of your AI client, and call export_roblox with upload:true.';
+});
+
+// src/roblox/export.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+async function exportRoblox(args, deps) {
+  const env = deps.env ?? process.env;
+  const opts = {
+    mode: args.mode ?? "hybrid",
+    targetResolution: args.targetResolution ?? [1920, 1080],
+    rasterize: args.rasterize ?? "auto",
+    asRootFrame: args.asRootFrame,
+    textScaled: args.textScaled,
+    fonts: args.fonts,
+    scale: 2
+  };
+  const t = await deps.request("roblox_tree", { nodeId: args.nodeId }, 120000);
+  const warnings = [];
+  if (t.truncated)
+    warnings.push(`Stopped after ${t.nodes} layers: export a smaller frame for the rest.`);
+  const wanted = pictureRequests(t.tree, opts);
+  const pictures = new Map;
+  for (let i = 0;i < wanted.length; i += 20) {
+    const r = await deps.request("roblox_images", { items: wanted.slice(i, i + 20).map((w) => ({ ...w, scale: opts.scale })) }, 120000);
+    for (const img of r.images) {
+      if (img.b64)
+        pictures.set(`${img.id}:${img.mode}`, { b64: img.b64, offset: img.offset, size: img.size });
+      else
+        warnings.push(`Picture of ${img.id} failed: ${img.error}`);
+    }
+  }
+  const assets = [];
+  const files = new Map;
+  const refs = new Map;
+  const names = new Map;
+  const layerNames = (n) => {
+    names.set(n.id, n.name);
+    for (const c of n.children ?? [])
+      layerNames(c);
+  };
+  layerNames(t.tree);
+  const add = (key, bytes, a, ext, ref) => {
+    const placeholder = `rbxassetid://PENDING_${assets.length + 1}`;
+    const file = `${String(assets.length + 1).padStart(2, "0")}-${safe(a.layer)}${a.mode && a.mode !== "full" ? `-${a.mode}` : ""}.${ext}`;
+    assets.push({ placeholder, file, ...a });
+    files.set(file, bytes);
+    refs.set(key, { url: placeholder, ...ref });
+  };
+  for (const w of wanted) {
+    const p = pictures.get(`${w.id}:${w.mode}`);
+    if (!p)
+      continue;
+    add(`${w.id}:${w.mode}`, new Uint8Array(Buffer.from(p.b64, "base64")), { nodeId: w.id, layer: names.get(w.id) ?? w.id, kind: "picture", mode: w.mode }, "png", { offset: p.offset, size: p.size });
+  }
+  for (const hash of imageHashes(t.tree)) {
+    const b64 = t.images[hash];
+    if (!b64)
+      continue;
+    const bytes = new Uint8Array(Buffer.from(b64, "base64"));
+    const info = imageInfo(bytes);
+    if (info && info.format !== "png" && info.format !== "jpeg")
+      warnings.push(`An image is ${info.format.toUpperCase()}: Roblox takes PNG, JPG, BMP or TGA, convert it before uploading.`);
+    const owner = findImageOwner(t.tree, hash);
+    add(`image:${hash}`, bytes, { nodeId: owner?.id ?? "", layer: owner?.name ?? "image", kind: "image" }, info?.format === "jpeg" ? "jpg" : info?.format ?? "png", {});
+  }
+  const mapped = mapToRoblox(t.tree, opts, (key) => refs.get(key));
+  warnings.push(...mapped.warnings);
+  let rbxmx = toRbxmx(mapped.root);
+  let luau = toLuau(mapped.root, { parent: args.parent, source: `${t.tree.name}" in "${t.fileName}` });
+  let uploaded = false;
+  if (args.upload) {
+    if (!env.ROBLOX_API_KEY || !env.ROBLOX_CREATOR_ID)
+      warnings.push(`upload skipped: ROBLOX_API_KEY and ROBLOX_CREATOR_ID are not set. ${UPLOAD_HELP}`);
+    else if (assets.length) {
+      const uploader = new RobloxUploader({
+        apiKey: env.ROBLOX_API_KEY,
+        creatorId: env.ROBLOX_CREATOR_ID,
+        cacheFile: join2(env.FIGMA_BRIDGE_HOME ?? join2(homedir(), ".figma-bridge"), "roblox-assets.json"),
+        fetchImpl: deps.fetchImpl,
+        sleep: deps.sleep
+      });
+      const ids = {};
+      for (const a of assets) {
+        const r = await uploader.upload(files.get(a.file), `${a.layer}${a.mode && a.mode !== "full" ? ` ${a.mode}` : ""}`);
+        a.assetId = r.assetId;
+        a.cached = r.cached;
+        ids[a.placeholder] = r.assetId;
+      }
+      rbxmx = substituteAssets(rbxmx, ids);
+      luau = substituteAssets(luau, ids);
+      uploaded = true;
+    }
+  }
+  const dir = args.outDir ?? join2(deps.outDir, `roblox-${safe(t.tree.name)}-${Date.now()}`);
+  mkdirSync3(dir, { recursive: true });
+  const base = safe(mapped.root.name);
+  writeFileSync3(join2(dir, `${base}.rbxmx`), rbxmx);
+  writeFileSync3(join2(dir, `${base}.luau`), luau);
+  for (const [file, bytes] of files)
+    writeFileSync3(join2(dir, file), bytes);
+  writeFileSync3(join2(dir, "assets.json"), JSON.stringify(assets, null, 2));
+  const pending = assets.filter((a) => !a.assetId);
+  const next = pending.length ? `Upload the ${pending.length} picture(s) in ${dir} (assets[].file) with your Roblox Studio tools (e.g. upload_image), replace each placeholder (rbxassetid://PENDING_n) in the Luau with the returned id, run it with execute_luau, then check it with a Studio screenshot. Or set ROBLOX_API_KEY and ROBLOX_CREATOR_ID and call export_roblox with upload:true.` : "Run the Luau with execute_luau (it replaces a previous copy and returns the root), or insert the .rbxmx in Studio, then check it with a Studio screenshot.";
+  return {
+    result: {
+      root: mapped.root.name,
+      dir,
+      rbxmx: join2(dir, `${base}.rbxmx`),
+      luau: join2(dir, `${base}.luau`),
+      assets: assets.map((a) => ({ ...a, file: join2(dir, a.file) })),
+      uploaded,
+      instances: mapped.counts.instances,
+      layers: t.nodes,
+      options: { mode: opts.mode, targetResolution: opts.targetResolution, rasterize: opts.rasterize },
+      ...Object.keys(mapped.fontSubstitutions).length ? { fontSubstitutions: mapped.fontSubstitutions } : {},
+      ...warnings.length ? { warnings: warnings.slice(0, 60) } : {},
+      next
+    },
+    luau,
+    rbxmx
+  };
+}
+function findImageOwner(n, hash) {
+  if ((n.fills ?? []).some((f) => f.imageHash === hash))
+    return n;
+  for (const c of n.children ?? []) {
+    const hit = findImageOwner(c, hash);
+    if (hit)
+      return hit;
+  }
+  return null;
+}
+var safe = (s) => s.replace(/[^\w.-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "ui";
+var init_export = __esm(() => {
+  init_image();
+  init_map2();
+  init_output();
+  init_upload();
+});
+
+// src/rest.ts
+function fileKeyFrom(input) {
+  const m = /figma\.com\/(?:file|design|board|slides|proto|deck)\/([A-Za-z0-9]{10,})/.exec(input);
+  if (m)
+    return m[1];
+  return /^[A-Za-z0-9]{10,}$/.test(input.trim()) ? input.trim() : null;
+}
+
+class FigmaRest {
+  token;
+  fetchImpl;
+  sleep;
+  base;
+  constructor(token, fetchImpl = fetch, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), base = process.env.FIGMA_API_URL || "https://api.figma.com") {
+    this.token = token;
+    this.fetchImpl = fetchImpl;
+    this.sleep = sleep;
+    this.base = base;
+  }
+  async call(method, path, body) {
+    let delay = 1000;
+    for (let attempt = 0;; attempt++) {
+      let res;
+      try {
+        res = await this.fetchImpl(this.base + path, {
+          method,
+          headers: { "X-Figma-Token": this.token, ...body !== undefined ? { "Content-Type": "application/json" } : {} },
+          body: body !== undefined ? JSON.stringify(body) : undefined,
+          signal: AbortSignal.timeout(60000)
+        });
+      } catch (e) {
+        if (attempt >= 3)
+          throw new RestError(`Figma API unreachable: ${e.message}`, "NETWORK");
+        await this.sleep(delay);
+        delay *= 2;
+        continue;
+      }
+      if (res.ok)
+        return res.status === 204 ? {} : await res.json();
+      const retryAfter = Number(res.headers.get("retry-after"));
+      if ((res.status === 429 || res.status >= 500) && attempt < 3) {
+        await this.sleep(res.status === 429 && retryAfter > 0 ? Math.min(retryAfter, 120) * 1000 : delay);
+        delay *= 2;
+        continue;
+      }
+      let detail = "";
+      try {
+        const j = await res.json();
+        detail = j.err ?? j.message ?? "";
+      } catch {}
+      if (res.status === 403)
+        throw new RestError(`Figma API refused the request (403${detail ? `: ${detail}` : ""}). Check that FIGMA_TOKEN is valid, has the needed scopes and can open this file.`, "FORBIDDEN", 403);
+      if (res.status === 404)
+        throw new RestError(`Not found (404${detail ? `: ${detail}` : ""}): check the file key or id.`, "NOT_FOUND", 404);
+      if (res.status === 429)
+        throw new RestError("Figma API rate limit reached: try again in a minute.", "RATE_LIMITED", 429);
+      throw new RestError(`Figma API error ${res.status}${detail ? `: ${detail}` : ""}`, "REST_ERROR", res.status);
+    }
+  }
+  async comments(key) {
+    const r = await this.call("GET", `/v1/files/${key}/comments?as_md=true`);
+    return r.comments ?? [];
+  }
+  postComment(key, message, opts = {}) {
+    const body = { message };
+    if (opts.replyTo)
+      body.comment_id = opts.replyTo;
+    else if (opts.nodeId)
+      body.client_meta = { node_id: opts.nodeId, node_offset: opts.offset ?? { x: 0, y: 0 } };
+    return this.call("POST", `/v1/files/${key}/comments`, body);
+  }
+  deleteComment(key, id) {
+    return this.call("DELETE", `/v1/files/${key}/comments/${id}`);
+  }
+  async versions(key, limit = 30) {
+    const out = [];
+    let before;
+    while (out.length < limit) {
+      const r = await this.call("GET", `/v1/files/${key}/versions?page_size=${Math.min(50, limit)}${before ? `&before=${before}` : ""}`);
+      out.push(...r.versions ?? []);
+      const next = r.pagination?.prev_page ? new URL(r.pagination.prev_page).searchParams.get("before") : null;
+      if (!next || !r.versions?.length)
+        break;
+      before = next;
+    }
+    return out.slice(0, limit);
+  }
+  async nodes(key, ids, version) {
+    const q = `ids=${encodeURIComponent(ids.join(","))}${version ? `&version=${encodeURIComponent(version)}` : ""}`;
+    const r = await this.call("GET", `/v1/files/${key}/nodes?${q}`);
+    const out = {};
+    for (const [id, n] of Object.entries(r.nodes ?? {}))
+      if (n?.document)
+        out[id] = n.document;
+    return out;
+  }
+  async pages(key, version) {
+    const r = await this.call("GET", `/v1/files/${key}?depth=1${version ? `&version=${encodeURIComponent(version)}` : ""}`);
+    return r.document?.children ?? [];
+  }
+}
+function threadComments(list, includeResolved) {
+  const replies = new Map;
+  for (const c of list)
+    if (c.parent_id)
+      replies.set(c.parent_id, [...replies.get(c.parent_id) ?? [], c]);
+  const brief = (c) => ({ id: c.id, author: c.user?.handle, message: c.message, createdAt: c.created_at });
+  return list.filter((c) => !c.parent_id && (includeResolved || !c.resolved_at)).sort((a, b) => a.created_at.localeCompare(b.created_at)).map((c) => ({
+    ...brief(c),
+    ...c.order_id ? { number: Number(c.order_id) } : {},
+    ...c.resolved_at ? { resolvedAt: c.resolved_at } : {},
+    ...c.client_meta?.node_id ? { nodeId: c.client_meta.node_id } : {},
+    replies: (replies.get(c.id) ?? []).sort((a, b) => a.created_at.localeCompare(b.created_at)).map(brief)
+  }));
+}
+function flatten(root, prefix, out) {
+  const seen = new Map;
+  for (const c of root.children ?? []) {
+    const n = (seen.get(c.name) ?? 0) + 1;
+    seen.set(c.name, n);
+    const path = `${prefix}${c.name}${n > 1 ? ` #${n}` : ""}`;
+    out.set(path, c);
+    flatten(c, `${path}/`, out);
+  }
+}
+function diffTrees(before, after, max = 200) {
+  const a = new Map;
+  const b = new Map;
+  flatten(before, "", a);
+  flatten(after, "", b);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [path, n] of b)
+    if (!a.has(path))
+      added.push({ path, type: n.type, id: n.id });
+  for (const [path, n] of a)
+    if (!b.has(path))
+      removed.push({ path, type: n.type, id: n.id });
+  for (const [path, now] of b) {
+    const old = a.get(path);
+    if (!old)
+      continue;
+    const c = [];
+    if (old.type !== now.type)
+      c.push(`type ${old.type} → ${now.type}`);
+    if ((old.visible ?? true) !== (now.visible ?? true))
+      c.push(now.visible === false ? "hidden" : "shown");
+    if ((old.characters ?? "") !== (now.characters ?? ""))
+      c.push(`text "${(old.characters ?? "").slice(0, 60)}" → "${(now.characters ?? "").slice(0, 60)}"`);
+    const ob = old.absoluteBoundingBox;
+    const nb = now.absoluteBoundingBox;
+    if (ob && nb) {
+      if (Math.abs(ob.width - nb.width) > 0.5 || Math.abs(ob.height - nb.height) > 0.5)
+        c.push(`size ${Math.round(ob.width)}×${Math.round(ob.height)} → ${Math.round(nb.width)}×${Math.round(nb.height)}`);
+      if (Math.abs(ob.x - nb.x) > 0.5 || Math.abs(ob.y - nb.y) > 0.5)
+        c.push(`moved ${Math.round(nb.x - ob.x)}, ${Math.round(nb.y - ob.y)}`);
+    }
+    if (fillsOf(old) !== fillsOf(now))
+      c.push(`fill ${fillsOf(old) || "none"} → ${fillsOf(now) || "none"}`);
+    if (c.length)
+      changed.push({ path, type: now.type, id: now.id, changes: c });
+  }
+  const movedOnly = (x) => x.changes.length === 1 && x.changes[0].startsWith("moved");
+  const movedPaths = new Set(changed.filter(movedOnly).map((x) => x.path));
+  const cleaned = changed.filter((x) => !(movedOnly(x) && [...movedPaths].some((p) => p !== x.path && x.path.startsWith(`${p}/`))));
+  const top = (list) => list.filter((x) => !list.some((y) => y !== x && x.path.startsWith(`${y.path}/`)));
+  const addedTop = top(added);
+  const removedTop = top(removed);
+  return {
+    summary: { added: addedTop.length, removed: removedTop.length, changed: cleaned.length, layersBefore: a.size, layersAfter: b.size },
+    added: addedTop.slice(0, max),
+    removed: removedTop.slice(0, max),
+    changed: cleaned.slice(0, max),
+    truncated: addedTop.length > max || removedTop.length > max || cleaned.length > max
+  };
+}
+var TOKEN_HELP, RestError, hex = (c) => "#" + [c.r, c.g, c.b].map((v) => Math.round(v * 255).toString(16).padStart(2, "0")).join("").toUpperCase() + (c.a < 0.999 ? Math.round(c.a * 255).toString(16).padStart(2, "0").toUpperCase() : ""), fillsOf = (n) => (n.fills ?? []).filter((f) => f.visible !== false).map((f) => f.type === "SOLID" && f.color ? hex(f.color) : f.type.toLowerCase()).join(",");
+var init_rest = __esm(() => {
+  TOKEN_HELP = "These features use Figma's REST API and need a personal access token. In Figma: Settings → Security → " + "Personal access tokens → Generate (scopes: file_content:read, file_comments:write, file_versions:read). " + 'Then add it to the Figma Bridge entry of your AI client config: "env": {"FIGMA_TOKEN": "figd_…"}, and restart the client.';
+  RestError = class RestError extends Error {
+    code;
+    status;
+    constructor(message, code, status) {
+      super(message);
+      this.code = code;
+      this.status = status;
+    }
+  };
+});
+
 // src/project/detect.ts
-import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
-import { join as join2, relative, sep } from "node:path";
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3, statSync } from "node:fs";
+import { join as join3, relative, sep } from "node:path";
 function listFiles(root, filter, max = 4000) {
   const out = [];
   const walk = (dir, depth) => {
@@ -26816,7 +28481,7 @@ function listFiles(root, filter, max = 4000) {
     for (const name of entries.sort()) {
       if (IGNORE.has(name) || name.startsWith(".") && name !== ".storybook")
         continue;
-      const full = join2(dir, name);
+      const full = join3(dir, name);
       let st;
       try {
         st = statSync(full);
@@ -26839,19 +28504,19 @@ function listFiles(root, filter, max = 4000) {
 }
 function readJsonc(path) {
   try {
-    const text = readFileSync2(path, "utf8").replace(/("(?:[^"\\]|\\.)*")|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (m, str) => str ?? "").replace(/,(\s*[}\]])/g, "$1");
+    const text = readFileSync3(path, "utf8").replace(/("(?:[^"\\]|\\.)*")|\/\/[^\n]*|\/\*[\s\S]*?\*\//g, (m, str) => str ?? "").replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(text);
   } catch {
     return null;
   }
 }
 function detectStack(root) {
-  const pkg = readJsonc(join2(root, "package.json"));
+  const pkg = readJsonc(join3(root, "package.json"));
   if (!pkg)
     throw new Error(`No package.json in ${root}: give the root folder of a JavaScript project as projectPath.`);
   const deps = { ...pkg.peerDependencies, ...pkg.devDependencies, ...pkg.dependencies };
   const has = (d) => deps[d] !== undefined;
-  const at = (...p) => existsSync2(join2(root, ...p));
+  const at = (...p) => existsSync2(join3(root, ...p));
   const evidence = [];
   let kind = "html";
   let framework = "html";
@@ -26887,7 +28552,7 @@ function detectStack(root) {
     styling = "css-modules";
   evidence.push(`styling: ${styling}`);
   const ui = [];
-  const shadcn = readJsonc(join2(root, "components.json"));
+  const shadcn = readJsonc(join3(root, "components.json"));
   if (shadcn?.aliases || has("class-variance-authority") && sourceFiles.some((f) => /components\/ui\/button\.(t|j)sx$/.test(f)))
     ui.push("shadcn");
   if (has("@mui/material"))
@@ -26896,7 +28561,7 @@ function detectStack(root) {
     ui.push("chakra");
   if (ui.length)
     evidence.push(`ui: ${ui.join(", ")}`);
-  const tsconfig = readJsonc(join2(root, "tsconfig.json")) ?? readJsonc(join2(root, "jsconfig.json"));
+  const tsconfig = readJsonc(join3(root, "tsconfig.json")) ?? readJsonc(join3(root, "jsconfig.json"));
   const typescript = at("tsconfig.json") || has("typescript");
   const aliases = [];
   const paths = tsconfig?.compilerOptions?.paths ?? {};
@@ -26905,7 +28570,7 @@ function detectStack(root) {
     const target = Array.isArray(targets) ? String(targets[0]) : "";
     if (!key.endsWith("/*") || !target.endsWith("/*"))
       continue;
-    const t = join2(baseUrl, target.slice(0, -2)).split(sep).join("/").replace(/^\.\//, "");
+    const t = join3(baseUrl, target.slice(0, -2)).split(sep).join("/").replace(/^\.\//, "");
     aliases.push({ prefix: key.slice(0, -1), target: t === "." ? "" : `${t}/` });
   }
   if (kind === "nuxt" && !aliases.length)
@@ -26942,8 +28607,8 @@ var init_detect = __esm(() => {
 });
 
 // src/project/components.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { basename, join as join3 } from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { basename, join as join4 } from "node:path";
 function block(text, start, open = "{", close = "}") {
   let depth = 0;
   for (let i = start;i < text.length; i++) {
@@ -27123,7 +28788,7 @@ function indexComponents(stack, max = 400) {
   for (const file of files) {
     let src;
     try {
-      src = readFileSync3(join3(stack.root, file), "utf8");
+      src = readFileSync4(join4(stack.root, file), "utf8");
     } catch {
       continue;
     }
@@ -27174,14 +28839,14 @@ var init_components = __esm(() => {
 });
 
 // src/project/mapping.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync5 } from "node:fs";
+import { join as join5 } from "node:path";
 function loadMapFile(root) {
-  const path = join4(root, MAP_FILE);
+  const path = join5(root, MAP_FILE);
   if (!existsSync3(path))
     return { map: {} };
   try {
-    return { map: JSON.parse(readFileSync4(path, "utf8")), path };
+    return { map: JSON.parse(readFileSync5(path, "utf8")), path };
   } catch (e) {
     return { map: {}, error: `${MAP_FILE} is not valid JSON: ${e.message}` };
   }
@@ -27338,8 +29003,8 @@ var init_mapping = __esm(() => {
 });
 
 // src/project/tokens.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import { join as join5 } from "node:path";
+import { readFileSync as readFileSync6 } from "node:fs";
+import { join as join6 } from "node:path";
 function oklch(l, c, h, a) {
   const hr = h * Math.PI / 180;
   return oklab(l, c * Math.cos(hr), c * Math.sin(hr), a);
@@ -27426,7 +29091,7 @@ function loadTokens(stack) {
   for (const file of stack.cssFiles) {
     let css;
     try {
-      css = readFileSync5(join5(stack.root, file), "utf8");
+      css = readFileSync6(join6(stack.root, file), "utf8");
     } catch {
       continue;
     }
@@ -27470,7 +29135,7 @@ function loadTokens(stack) {
   }
   if (stack.tailwind === 3 && stack.tailwindConfig) {
     try {
-      for (const t of tailwind3Colors(readFileSync5(join5(stack.root, stack.tailwindConfig), "utf8")))
+      for (const t of tailwind3Colors(readFileSync6(join6(stack.root, stack.tailwindConfig), "utf8")))
         index.add(t);
       index.sources.push(stack.tailwindConfig);
     } catch {}
@@ -27534,8 +29199,8 @@ var init_tokens2 = __esm(() => {
 });
 
 // src/project/plan.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join6, posix } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname3, join as join7, posix } from "node:path";
 function planProjectExport(root, tree, assets, opts = {}) {
   const stack = detectStack(root);
   if (opts.framework)
@@ -27607,19 +29272,19 @@ function planProjectExport(root, tree, assets, opts = {}) {
 }
 function writePlan(root, files, overwrite) {
   return files.map((f) => {
-    const target = join6(root, f.path);
+    const target = join7(root, f.path);
     const next = typeof f.content === "string" ? Buffer.from(f.content) : Buffer.from(f.content);
     if (existsSync4(target)) {
-      const before = readFileSync6(target);
+      const before = readFileSync7(target);
       if (before.equals(next))
         return { path: f.path, status: "unchanged" };
       if (!overwrite)
         return { path: f.path, status: "skipped (exists)" };
-      writeFileSync2(target, next);
+      writeFileSync4(target, next);
       return { path: f.path, status: "updated" };
     }
-    mkdirSync2(dirname2(target), { recursive: true });
-    writeFileSync2(target, next);
+    mkdirSync4(dirname3(target), { recursive: true });
+    writeFileSync4(target, next);
     return { path: f.path, status: "created" };
   });
 }
@@ -27688,7 +29353,7 @@ class FontIndex {
   }
 }
 var GENERIC, STYLE_WEIGHTS;
-var init_fonts = __esm(() => {
+var init_fonts2 = __esm(() => {
   GENERIC = {
     "sans-serif": ["Inter", "Roboto", "Arial", "Helvetica"],
     "system-ui": ["Inter", "SF Pro Text", "Segoe UI", "Roboto", "Arial"],
@@ -27838,7 +29503,7 @@ function cssLiteral(v, value) {
   if (typeof value === "boolean")
     return null;
   if (typeof value === "number")
-    return unitless(v) ? num(value) : `${num(value)}px`;
+    return unitless(v) ? num2(value) : `${num2(value)}px`;
   if (v.type === "string" && category(v) === "fontFamily")
     return /^[\w-]+$/.test(String(value)) ? String(value) : quote(String(value));
   if (v.type === "string")
@@ -27846,12 +29511,12 @@ function cssLiteral(v, value) {
   return String(value);
 }
 function gradientCss(g) {
-  const stops = g.gradient.map((s) => `${s.color} ${num(s.at * 100)}%`).join(", ");
+  const stops = g.gradient.map((s) => `${s.color} ${num2(s.at * 100)}%`).join(", ");
   if (g.type === "radial")
     return `radial-gradient(circle, ${stops})`;
   if (g.type)
     return `conic-gradient(${stops})`;
-  return `linear-gradient(${num((g.angle ?? 0) + 90)}deg, ${stops})`;
+  return `linear-gradient(${num2((g.angle ?? 0) + 90)}deg, ${stops})`;
 }
 function paintCss(value, ref) {
   const one = (p) => typeof p === "string" ? p : p && p.alias ? ref(p.alias) : p && p.gradient ? gradientCss(p) : "transparent";
@@ -27860,7 +29525,7 @@ function paintCss(value, ref) {
   return value.slice().reverse().map((p) => typeof p === "string" || p && p.alias ? `linear-gradient(${one(p)}, ${one(p)})` : one(p)).join(", ");
 }
 function shadowCss(effects, ref) {
-  const list = effects.filter((e) => e.blur !== undefined && e.type === undefined).reverse().map((e) => `${e.inner ? "inset " : ""}${num(e.x)}px ${num(e.y)}px ${num(e.blur)}px ${num(e.spread ?? 0)}px ${e.colorVariable ? ref(e.colorVariable) : e.color}`);
+  const list = effects.filter((e) => e.blur !== undefined && e.type === undefined).reverse().map((e) => `${e.inner ? "inset " : ""}${num2(e.x)}px ${num2(e.y)}px ${num2(e.blur)}px ${num2(e.spread ?? 0)}px ${e.colorVariable ? ref(e.colorVariable) : e.color}`);
   return list.length ? list.join(", ") : null;
 }
 function textDecls(t, ref) {
@@ -27869,7 +29534,7 @@ function textDecls(t, ref) {
   const d = [
     ["font-family", bound.fontFamily ? ref(bound.fontFamily) : `${/^[\w-]+$/.test(t.font) ? t.font : quote(t.font)}, sans-serif`],
     ["font-weight", bound.fontWeight ? ref(bound.fontWeight) : String(w.weight)],
-    ["font-size", bound.fontSize ? ref(bound.fontSize) : `${num(t.size)}px`]
+    ["font-size", bound.fontSize ? ref(bound.fontSize) : `${num2(t.size)}px`]
   ];
   if (w.italic)
     d.push(["font-style", "italic"]);
@@ -28146,7 +29811,7 @@ ${textDecls(t, ref).map(([k, v]) => `  ${k}: ${v};`).join(`
 }
 function tsLiteral(value) {
   if (typeof value === "number")
-    return num(value);
+    return num2(value);
   if (typeof value === "boolean")
     return String(value);
   return quote(String(value));
@@ -28266,7 +29931,7 @@ function dtcgType(v) {
 function toDtcg(model) {
   const out = {};
   const dtcgRef = (a) => `{${[a.collection, ...a.name.split("/")].join(".")}}`;
-  const literal = (v, x) => isAlias(x) ? dtcgRef(x.alias) : dtcgType(v) === "dimension" ? `${num(Number(x))}px` : x;
+  const literal = (v, x) => isAlias(x) ? dtcgRef(x.alias) : dtcgType(v) === "dimension" ? `${num2(Number(x))}px` : x;
   for (const c of model.data.collections) {
     const group = { $extensions: { "figma-bridge": { collection: true, modes: c.modes } } };
     for (const v of c.variables) {
@@ -28297,9 +29962,9 @@ function toDtcg(model) {
     }
     for (const t of s.text) {
       const w = styleWeight(t.style);
-      const value = { fontFamily: t.font, fontWeight: w.weight, fontSize: `${num(t.size)}px` };
+      const value = { fontFamily: t.font, fontWeight: w.weight, fontSize: `${num2(t.size)}px` };
       if (t.lineHeight !== undefined)
-        value.lineHeight = typeof t.lineHeight === "number" ? `${num(t.lineHeight)}px` : t.lineHeight;
+        value.lineHeight = typeof t.lineHeight === "number" ? `${num2(t.lineHeight)}px` : t.lineHeight;
       if (t.letterSpacing !== undefined)
         value.letterSpacing = letterSpacingCss(t.letterSpacing);
       const token = { $type: "typography", $value: value, $extensions: { "figma-bridge": { style: t.style } } };
@@ -28313,7 +29978,7 @@ function toDtcg(model) {
         continue;
       const token = {
         $type: "shadow",
-        $value: shadows.map((x) => ({ color: x.color, offsetX: `${num(x.x)}px`, offsetY: `${num(x.y)}px`, blur: `${num(x.blur)}px`, spread: `${num(x.spread ?? 0)}px`, ...x.inner ? { inset: true } : {} }))
+        $value: shadows.map((x) => ({ color: x.color, offsetX: `${num2(x.x)}px`, offsetY: `${num2(x.y)}px`, blur: `${num2(x.blur)}px`, spread: `${num2(x.spread ?? 0)}px`, ...x.inner ? { inset: true } : {} }))
       };
       if (e.description)
         token.$description = e.description;
@@ -28360,9 +30025,9 @@ function exportTokenFiles(data, formats, opts = {}) {
   }
   return { files, warnings: [...data.warnings ?? [], ...model.warnings] };
 }
-var FORMATS, FILE_NAMES, isAlias = (v) => typeof v === "object" && v !== null && ("alias" in v), kebab2 = (s) => s.normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""), camel2 = (s) => kebab2(s).replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase()), num = (n) => String(Math.round(n * 1000) / 1000), quote = (s) => JSON.stringify(s), qualified = (collection, name) => `${collection}/${name}`, CATEGORY_WORDS, letterSpacingCss = (v) => v === undefined ? undefined : typeof v === "string" && v.endsWith("%") ? `${num(parseFloat(v) / 100)}em` : `${num(Number(v))}px`, lineHeightCss = (v) => v === undefined ? undefined : typeof v === "string" ? v : `${num(v)}px`, TW3_KEYS, TW4_NS;
+var FORMATS, FILE_NAMES, isAlias = (v) => typeof v === "object" && v !== null && ("alias" in v), kebab2 = (s) => s.normalize("NFKD").replace(/[̀-ͯ]/g, "").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""), camel2 = (s) => kebab2(s).replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase()), num2 = (n) => String(Math.round(n * 1000) / 1000), quote = (s) => JSON.stringify(s), qualified = (collection, name) => `${collection}/${name}`, CATEGORY_WORDS, letterSpacingCss = (v) => v === undefined ? undefined : typeof v === "string" && v.endsWith("%") ? `${num2(parseFloat(v) / 100)}em` : `${num2(Number(v))}px`, lineHeightCss = (v) => v === undefined ? undefined : typeof v === "string" ? v : `${num2(v)}px`, TW3_KEYS, TW4_NS;
 var init_tokens_export = __esm(() => {
-  init_fonts();
+  init_fonts2();
   FORMATS = ["dtcg", "css", "tailwind", "tailwind4", "scss", "ts", "json"];
   FILE_NAMES = {
     dtcg: "tokens.json",
@@ -29975,16 +31640,16 @@ var BUILD_LIMIT = 2800, isSvg = (bytes) => /^\s*(<\?xml[^>]*>\s*)?(<!--[\s\S]*?-
 var init_import = __esm(() => {
   init_browser();
   init_convert();
-  init_fonts();
+  init_fonts2();
 });
 
 // src/snippets.ts
-import { createHash } from "node:crypto";
-import { mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync, statSync as statSync2, writeFileSync as writeFileSync3 } from "node:fs";
-import { homedir } from "node:os";
-import { join as join7 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import { mkdirSync as mkdirSync5, readdirSync as readdirSync2, readFileSync as readFileSync8, rmSync, statSync as statSync2, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join8 } from "node:path";
 function ensureDir() {
-  mkdirSync3(SNIPPETS_DIR, { recursive: true });
+  mkdirSync5(SNIPPETS_DIR, { recursive: true });
 }
 function checkName(name) {
   if (!NAME.test(name))
@@ -29999,14 +31664,14 @@ function files() {
 }
 function listSnippets() {
   return files().map((f) => {
-    const source = readFileSync7(join7(SNIPPETS_DIR, f), "utf8");
+    const source = readFileSync8(join8(SNIPPETS_DIR, f), "utf8");
     return { name: f.slice(0, -3), description: header2(source, "description"), usage: header2(source, "usage") };
   });
 }
 function getSnippet(name) {
   checkName(name);
   try {
-    return readFileSync7(join7(SNIPPETS_DIR, `${name}.js`), "utf8");
+    return readFileSync8(join8(SNIPPETS_DIR, `${name}.js`), "utf8");
   } catch {
     throw new BridgeError(`No snippet named "${name}".`, "NOT_FOUND");
   }
@@ -30019,37 +31684,37 @@ function saveSnippet(name, code, description = "", usage = "") {
 // @usage ${usage.replace(/\n/g, " ") || `await lib.${name}(args)`}
 ${body}
 `;
-  const path = join7(SNIPPETS_DIR, `${name}.js`);
-  writeFileSync3(path, text);
+  const path = join8(SNIPPETS_DIR, `${name}.js`);
+  writeFileSync5(path, text);
   return path;
 }
 function deleteSnippet(name) {
   checkName(name);
-  rmSync(join7(SNIPPETS_DIR, `${name}.js`), { force: true });
+  rmSync(join8(SNIPPETS_DIR, `${name}.js`), { force: true });
 }
 function loadLibrary() {
   const list = files();
-  const stamp = list.map((f) => `${f}:${statSync2(join7(SNIPPETS_DIR, f)).mtimeMs}`).join("|");
+  const stamp = list.map((f) => `${f}:${statSync2(join8(SNIPPETS_DIR, f)).mtimeMs}`).join("|");
   if (cached2 && cached2.stamp === stamp)
     return cached2;
   const lib = {};
   for (const f of list)
-    lib[f.slice(0, -3)] = readFileSync7(join7(SNIPPETS_DIR, f), "utf8");
-  cached2 = { stamp, hash: stamp ? createHash("sha1").update(stamp + JSON.stringify(lib)).digest("base64url").slice(0, 12) : "empty", lib };
+    lib[f.slice(0, -3)] = readFileSync8(join8(SNIPPETS_DIR, f), "utf8");
+  cached2 = { stamp, hash: stamp ? createHash2("sha1").update(stamp + JSON.stringify(lib)).digest("base64url").slice(0, 12) : "empty", lib };
   return cached2;
 }
 var SNIPPETS_DIR, NAME, cached2 = null;
 var init_snippets = __esm(() => {
   init_bridge();
-  SNIPPETS_DIR = process.env.FIGMA_BRIDGE_SNIPPETS || join7(homedir(), ".figma-bridge", "snippets");
+  SNIPPETS_DIR = process.env.FIGMA_BRIDGE_SNIPPETS || join8(homedir2(), ".figma-bridge", "snippets");
   NAME = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
 });
 
 // src/server.ts
-import { appendFileSync, mkdirSync as mkdirSync4, statSync as statSync3, truncateSync, writeFileSync as writeFileSync4 } from "node:fs";
+import { appendFileSync, mkdirSync as mkdirSync6, statSync as statSync3, truncateSync, writeFileSync as writeFileSync6 } from "node:fs";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { dirname as dirname4, join as join9 } from "node:path";
 import { fileURLToPath } from "node:url";
 function log(line) {
   const text = `[${new Date().toISOString().slice(11, 23)}] ${line}`;
@@ -30140,6 +31805,12 @@ async function prepareSpec(spec, defaultColor) {
       return;
     if (Array.isArray(node))
       return node.forEach(walk);
+    if (String(node.type ?? "").toLowerCase() === "diagram") {
+      const expanded = diagramSpec(node);
+      for (const k of Object.keys(node))
+        delete node[k];
+      Object.assign(node, expanded);
+    }
     if (node.icon && !node.svg) {
       const size = typeof node.size === "number" ? node.size : 24;
       jobs.push(iconSvg(String(node.icon), size, typeof node.color === "string" ? node.color : defaultColor).then((svg) => void (node.svg = svg)));
@@ -30164,6 +31835,8 @@ async function prepareSpec(spec, defaultColor) {
       node.children.forEach(walk);
     if (Array.isArray(node.variants))
       node.variants.forEach(walk);
+    if (Array.isArray(node.slides))
+      node.slides.forEach(walk);
     if (node.base)
       walk(node.base);
   };
@@ -30175,7 +31848,7 @@ async function writeIfChanged(path, content) {
   const before = await readFile(path, "utf8").catch(() => null);
   if (before === content)
     return "unchanged";
-  await mkdir(dirname3(path), { recursive: true });
+  await mkdir(dirname4(path), { recursive: true });
   await writeFile(path, content);
   return before === null ? "created" : "updated";
 }
@@ -30189,7 +31862,46 @@ function renameAssets(n, names) {
     out.children = n.children.map((c) => renameAssets(c, names));
   return out;
 }
-var PORT, CHANNEL, OUT_DIR, LOG_FILE, MAX_OUTPUT_CHARS = 60000, MAX_IMAGE_BYTES, FIGMA_MAX_IMAGE_DIM = 4096, VIEW_MAX_DIM = 1568, bridge, ok = (value) => ({ content: [{ type: "text", text: json(value) }] }), plain = (text) => ({ content: [{ type: "text", text }] }), oneLine = (s, max = 120) => s.replace(/\s+/g, " ").trim().slice(0, max), safeName = (s) => s.replace(/[^\w.-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "node", server, shutdown = () => process.exit(0);
+async function restContext(fileUrl) {
+  const token = process.env.FIGMA_TOKEN;
+  if (!token)
+    throw new BridgeError(TOKEN_HELP, "NO_TOKEN");
+  const session = await bridge.current().catch(() => null);
+  let key = fileUrl ? fileKeyFrom(fileUrl) : null;
+  if (fileUrl && !key)
+    throw new BridgeError(`Not a Figma file link or key: ${fileUrl}`, "BAD_ARGS");
+  key ??= session?.fileKey ?? null;
+  if (!key) {
+    throw new BridgeError("Unknown file key: the plugin can't read it here (Figma gives it only to development and private plugins). Pass fileUrl: the file's link (Share → Copy link).", "NO_FILE_KEY");
+  }
+  return { rest: new FigmaRest(token), key, session: session?.fileKey === key ? session : null };
+}
+async function layerNames(session, ids) {
+  if (!session || !ids.length)
+    return {};
+  return bridge.request("node_info", { ids: [...new Set(ids)] }, 20000).catch(() => ({}));
+}
+var PORT, CHANNEL, OUT_DIR, LOG_FILE, MAX_OUTPUT_CHARS = 60000, MAX_IMAGE_BYTES, FIGMA_MAX_IMAGE_DIM = 4096, VIEW_MAX_DIM = 1568, bridge, ok = (value) => ({ content: [{ type: "text", text: json(value) }] }), plain = (text) => ({ content: [{ type: "text", text }] }), oneLine = (s, max = 120) => s.replace(/\s+/g, " ").trim().slice(0, max), safeName = (s) => s.replace(/[^\w.-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "node", INSTRUCTIONS, BUILD_DESCRIPTION = `Create a whole layout in ONE call from a declarative spec. Fonts load automatically, icons are fetched, images loaded. Much faster and safer than run_script for new UI.
+Node: {type?, name?, ...props, children?: Node[]}. type is inferred (text/spans→text, icon→icon, src→image, component→instance, variants→componentSet, else frame). Types: frame, component, componentSet, text, rect, ellipse, line, icon, image, svg, instance.
+FRAME: layout "row"|"column"|"grid" (auto-layout; omit for free positioning), gap (number|"auto"), padding (n | [v,h] | [t,r,b,l]), align (cross axis: start|center|end|baseline), justify (main axis: start|center|end|between), wrap, rowGap, clip. Frames have no fill unless set.
+GRID: layout:"grid", columns (count | tracks like [200,"1fr","2fr","hug"]), rows (same; default: enough rows, hugging), columnGap, rowGap (or gap). Children: span:[rows,cols] or colSpan/rowSpan, cellAlign/cellValign. Give the grid a w for "fr" columns.
+SIZE: w / h: number (fixed) | "fill" (stretch inside an auto-layout parent) | "hug". Auto-layout frames hug by default. grow:true. absolute:true with x/y inside auto-layout; x/y for children of free frames.
+TEXT: text, font ("Inter" | "Inter:Bold"), weight (400|500|600|700 or style name), size, color, lineHeight (1.5 | 24 | "150%"), letterSpacing (px | "2%"), align (left|center|right|justify), case (upper|lower|title), decoration (underline|strike), maxLines, textStyle "style:Name". Give w:"fill" or a number to wrap text.
+RICH TEXT: spans:[{text:"Read the "},{text:"docs",weight:600,color:"#0D99FF",link:"https://…"}] instead of text; a span may set font, weight, size, color, decoration, case, link.
+PAINT (fill, stroke, color): "#RRGGBB[AA]", "style:<paint style>", "var:<color variable>", {gradient:["#a","#b"], angle:90, type?:"radial"}, {image:"https://…"|path, fit:"fill"|"fit"|"crop"|"tile"}, null, or an array (last on top). stroke + strokeWidth (n | [t,r,b,l]) + strokeAlign (inside|center|outside) + strokeDash [dash,gap].
+EFFECTS: radius (n | [tl,tr,br,bl] | "var:x"), opacity, shadow (true | {x,y,blur,spread,color} | [...] | "style:Name"), blur, backgroundBlur, rotation, visible.
+ICON: {icon:"lucide:house", size:20, color:"#111"} (any Iconify set). IMAGE: {src:"C:/img.png" | "https://…", w, h, fit:"fill"|"fit"|"crop"|"tile"}. SVG: {svg:"<svg…>"}.
+INSTANCE: {component:"Button" | node id | library key, props:{Variant:"Primary", Label:"Buy"}, text:{"Label layer name":"Buy"}}.
+COMPONENT SET: {type:"componentSet", name:"Button", base:{shared frame spec}, variants:[{props:{Variant:"Primary",Size:"M"}, fill:"#0D99FF", children:[…]}, …], properties:{Label:"Button", "Show icon":{type:"boolean",default:true}, Icon:{type:"instance",default:"Icon/Star"}}}. One component per variant, combined as variants.
+On a layer inside a component: bind:"Label" links a text to a text property (created if missing); bind:{visible:"Show icon"} or {mainComponent:"Icon"} for the others. type:"component" takes properties too.
+PROTOTYPE: reactions:[{trigger:"click", action:"navigate", to:"Details", transition:"smart", duration:300}] on any layer (see the prototype tool).
+SECTION: {type:"section", name, children (placed with x/y), w?, h?} (wraps its children when no size).
+FIGJAM files: {type:"sticky", text, color:"yellow"|"blue"|…|"#hex", wide?}, {type:"shape", shape:"rounded"|"square"|"ellipse"|"diamond"|"database"|"hexagon"|…, text, w, h, fill, stroke}, {type:"connector", from, to, label?, line:"elbowed"|"straight"|"curved", dashed?, endArrow?:"arrow"|"none"} (from/to: layer name, key or id; any node can set key:"a"), {type:"table", rows:[["Name","Role"],["Ada","Eng"]]}, {type:"codeBlock", code, language:"typescript"}.
+DIAGRAM (FigJam): {type:"diagram", source:"flowchart LR\\n A[Start] --> B{Valid?}\\n B -->|yes| C(Done)\\n B -.->|no| A", as?:"shapes"|"stickies", name?} lays out a Mermaid flowchart (shapes [] () {} (()) [()] {{}}, edges --> --- -.-> ==> with |labels|, subgraphs → sections).
+SLIDES files: {slides:[{name, fill?, children:[…]}, …]} or {type:"slide", …}: one 1920×1080 slide per entry, children placed with x/y or auto-layout.
+gap/padding/radius accept "var:<number variable>". MODES: modes:{"Theme":"Dark"} sets a collection's variable mode on a frame and its children.
+Example: {"name":"Card","layout":"column","w":320,"padding":24,"gap":12,"fill":"#FFFFFF","radius":16,"shadow":true,"children":[{"text":"Pro plan","size":20,"weight":600},{"text":"Everything you need","color":"#6B7280","w":"fill"},{"layout":"row","gap":8,"align":"center","children":[{"icon":"lucide:check","size":16,"color":"#16A34A"},{"text":"Unlimited projects"}]}]}
+Returns {rootId, ids:{layerName:id}, created, warnings}. The result is selected and zoomed to unless select:false.`, server, SESSION_TOOLS, registerTool, toolDocs, shutdown = () => process.exit(0);
 var init_server3 = __esm(async () => {
   init_mcp();
   init_stdio2();
@@ -30198,6 +31910,10 @@ var init_server3 = __esm(async () => {
   init_icons();
   init_image();
   init_codegen();
+  init_diagram();
+  init_guides();
+  init_export();
+  init_rest();
   init_plan();
   init_tokens();
   init_tokens_export();
@@ -30206,38 +31922,58 @@ var init_server3 = __esm(async () => {
   init_package();
   PORT = Number(process.env.FIGMA_BRIDGE_PORT) || 3055;
   CHANNEL = process.env.FIGMA_BRIDGE_CHANNEL || "default";
-  OUT_DIR = process.env.FIGMA_BRIDGE_OUT || join8(tmpdir(), "figma-bridge");
-  LOG_FILE = join8(OUT_DIR, "bridge.log");
+  OUT_DIR = process.env.FIGMA_BRIDGE_OUT || join9(tmpdir(), "figma-bridge");
+  LOG_FILE = join9(OUT_DIR, "bridge.log");
   MAX_IMAGE_BYTES = 50 << 20;
-  mkdirSync4(OUT_DIR, { recursive: true });
+  mkdirSync6(OUT_DIR, { recursive: true });
   try {
     if (statSync3(LOG_FILE).size > 5 << 20)
       truncateSync(LOG_FILE, 0);
   } catch {}
   bridge = new Bridge({ port: PORT, channel: CHANNEL, version, log });
   bridge.start();
+  INSTRUCTIONS = [
+    "Figma Bridge drives the user's Figma desktop app through a local plugin. No rate limits: iterate freely.",
+    "Workflow:",
+    "1. get_context, then get_design_system when the file has styles, variables or components: reuse them instead of raw values. find locates layers by name, text, type, style or component across pages.",
+    "2. New UI → build (one call per screen or section, with auto-layout; grid, rich text spans, component sets with variants, prototype reactions). Editing existing design → describe it first, then build into it (parentId) or run_script.",
+    "3. Design system → design_tokens writes variables (with Light/Dark modes) and styles from simple JSON, W3C tokens or a Tailwind theme; build uses them via var:, style: and modes.",
+    "4. Verify → screenshot with returnImage:true, and audit to catch contrast, overflow and naming issues. Fix, then check again. audit {scope:'design-system'} scores the file's design system; audit {fix:true} binds raw values to variables and styles.",
+    "Reproduce a mockup or screenshot: build it at the mockup's size → compare {nodeId, reference, returnImage:true} → fix the largest regions → compare again until mismatchPercent stops dropping.",
+    "5. Before risky changes to existing work → checkpoint {action:'save'}; restore if the result is worse. Each command is one Ctrl+Z step for the user.",
+    "Existing website or HTML → import_web turns it into editable auto-layout frames (one per viewport); then compare against the returned reference screenshot.",
+    "When the target is unclear, wait_for_selection asks the user to pick it in Figma. prototype links screens, annotate leaves Dev Mode notes, export_code turns a frame into code; give it projectPath to reuse the project's components and tokens.",
+    "run_script: `figma` global, top-level await, `return` a small JSON value (nodes come back as {id,name,type}).",
+    "Script helpers: utils.loadFonts('Inter:Bold', …), utils.node(id), utils.page(name), utils.hex('#hex'), utils.solid('#hex', opacity?),",
+    "utils.build(spec, {parentId}), utils.describe(nodeOrId, depth); lib.<name>(args) runs a saved snippet; console.log is returned as `logs`.",
+    "Save helpers you will reuse with the snippets tool. Icons: search_icons, then insert_icon or {icon:'set:name'} in build.",
+    "Rules: load fonts before editing text; pages load on demand (await figma.setCurrentPageAsync / getNodeByIdAsync); keep results small.",
+    "The user can cancel a command from the plugin (code CANCELLED): build stops, a script may still finish, so check the file before retrying.",
+    "With FIGMA_TOKEN set: comments reads and posts file comments pinned to layers, versions lists the history and diffs a version against now.",
+    "Roblox: export_roblox turns a frame into a ScreenGui (.rbxmx + Luau for execute_luau + PNG assets); with a Roblox Studio MCP, upload the assets, run the Luau and check a Studio screenshot.",
+    "Prompts new-screen, apply-design-system, reproduce-screenshot, import-website, figma-to-code, audit-and-fix and figma-to-roblox are ready-made workflows; the resources figma-bridge://docs/build-spec and figma-bridge://docs/workflow are the full reference.",
+    "If no file is connected, tell the user to run Plugins → Development → Figma Bridge in Figma (Ctrl+Alt+P re-runs it). If list_sessions reports versionMismatch, ask them to reopen or update the plugin."
+  ];
   server = new McpServer({ name: "figma-bridge", version }, {
-    instructions: [
-      "Figma Bridge drives the user's Figma desktop app through a local plugin. No rate limits: iterate freely.",
-      "Workflow:",
-      "1. get_context, then get_design_system when the file has styles, variables or components: reuse them instead of raw values. find locates layers by name, text, type, style or component across pages.",
-      "2. New UI → build (one call per screen or section, with auto-layout; grid, rich text spans, component sets with variants, prototype reactions). Editing existing design → describe it first, then build into it (parentId) or run_script.",
-      "3. Design system → design_tokens writes variables (with Light/Dark modes) and styles from simple JSON, W3C tokens or a Tailwind theme; build uses them via var:, style: and modes.",
-      "4. Verify → screenshot with returnImage:true, and audit to catch contrast, overflow and naming issues. Fix, then check again. audit {scope:'design-system'} scores the file's design system; audit {fix:true} binds raw values to variables and styles.",
-      "Reproduce a mockup or screenshot: build it at the mockup's size → compare {nodeId, reference, returnImage:true} → fix the largest regions → compare again until mismatchPercent stops dropping.",
-      "5. Before risky changes to existing work → checkpoint {action:'save'}; restore if the result is worse. Each command is one Ctrl+Z step for the user.",
-      "Existing website or HTML → import_web turns it into editable auto-layout frames (one per viewport); then compare against the returned reference screenshot.",
-      "When the target is unclear, wait_for_selection asks the user to pick it in Figma. prototype links screens, annotate leaves Dev Mode notes, export_code turns a frame into code; give it projectPath to reuse the project's components and tokens.",
-      "run_script: `figma` global, top-level await, `return` a small JSON value (nodes come back as {id,name,type}).",
-      "Script helpers: utils.loadFonts('Inter:Bold', …), utils.node(id), utils.page(name), utils.hex('#hex'), utils.solid('#hex', opacity?),",
-      "utils.build(spec, {parentId}), utils.describe(nodeOrId, depth); lib.<name>(args) runs a saved snippet; console.log is returned as `logs`.",
-      "Save helpers you will reuse with the snippets tool. Icons: search_icons, then insert_icon or {icon:'set:name'} in build.",
-      "Rules: load fonts before editing text; pages load on demand (await figma.setCurrentPageAsync / getNodeByIdAsync); keep results small.",
-      "The user can cancel a command from the plugin (code CANCELLED): build stops, a script may still finish, so check the file before retrying.",
-      "If no file is connected, tell the user to run Plugins → Development → Figma Bridge in Figma (Ctrl+Alt+P re-runs it). If list_sessions reports versionMismatch, ask them to reopen or update the plugin."
-    ].join(`
+    instructions: INSTRUCTIONS.join(`
 `)
   });
+  SESSION_TOOLS = new Set(["list_sessions", "select_session"]);
+  registerTool = server.registerTool.bind(server);
+  toolDocs = [];
+  server.registerTool = (name, config, handler) => {
+    toolDocs.push({ name, title: config.title, description: config.description ?? "" });
+    if (SESSION_TOOLS.has(name))
+      return registerTool(name, config, handler);
+    const inputSchema = {
+      ...config.inputSchema,
+      file: string2().optional().describe("Target file name or session id when several files are connected (default: the selected file)")
+    };
+    return registerTool(name, { ...config, inputSchema }, (args, extra) => {
+      const { file, ...rest } = args ?? {};
+      return callTarget.run({ file: typeof file === "string" && file ? file : undefined }, () => handler(rest, extra));
+    });
+  };
   server.registerTool("run_script", {
     title: "Run Figma Plugin API script",
     description: "Execute JavaScript in the Figma plugin main thread (full Plugin API via `figma`). The code is the body of an async " + "function: use top-level await and `return` the output (JSON-serialized; a single expression is returned automatically). " + "Helpers: utils.loadFonts, utils.node, utils.page, utils.hex, utils.solid, utils.build, utils.describe; lib.<snippet>(args); " + "console.log is captured. On error returns {ok:false, error, line, stack}. Prefer build for creating new layouts. " + "If the user presses Cancel in the plugin you get code CANCELLED, but a script cannot be interrupted and may still finish: check the file before retrying.",
@@ -30253,23 +31989,7 @@ var init_server3 = __esm(async () => {
   }));
   server.registerTool("build", {
     title: "Build a layout from a JSON spec",
-    description: `Create a whole layout in ONE call from a declarative spec. Fonts load automatically, icons are fetched, images loaded. Much faster and safer than run_script for new UI.
-Node: {type?, name?, ...props, children?: Node[]}. type is inferred (text/spans→text, icon→icon, src→image, component→instance, variants→componentSet, else frame). Types: frame, component, componentSet, text, rect, ellipse, line, icon, image, svg, instance.
-FRAME: layout "row"|"column"|"grid" (auto-layout; omit for free positioning), gap (number|"auto"), padding (n | [v,h] | [t,r,b,l]), align (cross axis: start|center|end|baseline), justify (main axis: start|center|end|between), wrap, rowGap, clip. Frames have no fill unless set.
-GRID: layout:"grid", columns (count | tracks like [200,"1fr","2fr","hug"]), rows (same; default: enough rows, hugging), columnGap, rowGap (or gap). Children: span:[rows,cols] or colSpan/rowSpan, cellAlign/cellValign. Give the grid a w for "fr" columns.
-SIZE: w / h: number (fixed) | "fill" (stretch inside an auto-layout parent) | "hug". Auto-layout frames hug by default. grow:true. absolute:true with x/y inside auto-layout; x/y for children of free frames.
-TEXT: text, font ("Inter" | "Inter:Bold"), weight (400|500|600|700 or style name), size, color, lineHeight (1.5 | 24 | "150%"), letterSpacing (px | "2%"), align (left|center|right|justify), case (upper|lower|title), decoration (underline|strike), maxLines, textStyle "style:Name". Give w:"fill" or a number to wrap text.
-RICH TEXT: spans:[{text:"Read the "},{text:"docs",weight:600,color:"#0D99FF",link:"https://…"}] instead of text; a span may set font, weight, size, color, decoration, case, link.
-PAINT (fill, stroke, color): "#RRGGBB[AA]", "style:<paint style>", "var:<color variable>", {gradient:["#a","#b"], angle:90, type?:"radial"}, {image:"https://…"|path, fit:"fill"|"fit"|"crop"|"tile"}, null, or an array (last on top). stroke + strokeWidth (n | [t,r,b,l]) + strokeAlign (inside|center|outside) + strokeDash [dash,gap].
-EFFECTS: radius (n | [tl,tr,br,bl] | "var:x"), opacity, shadow (true | {x,y,blur,spread,color} | [...] | "style:Name"), blur, backgroundBlur, rotation, visible.
-ICON: {icon:"lucide:house", size:20, color:"#111"} (any Iconify set). IMAGE: {src:"C:/img.png" | "https://…", w, h, fit:"fill"|"fit"|"crop"|"tile"}. SVG: {svg:"<svg…>"}.
-INSTANCE: {component:"Button" | node id | library key, props:{Variant:"Primary", Label:"Buy"}, text:{"Label layer name":"Buy"}}.
-COMPONENT SET: {type:"componentSet", name:"Button", base:{shared frame spec}, variants:[{props:{Variant:"Primary",Size:"M"}, fill:"#0D99FF", children:[…]}, …], properties:{Label:"Button", "Show icon":{type:"boolean",default:true}, Icon:{type:"instance",default:"Icon/Star"}}}. One component per variant, combined as variants.
-On a layer inside a component: bind:"Label" links a text to a text property (created if missing); bind:{visible:"Show icon"} or {mainComponent:"Icon"} for the others. type:"component" takes properties too.
-PROTOTYPE: reactions:[{trigger:"click", action:"navigate", to:"Details", transition:"smart", duration:300}] on any layer (see the prototype tool).
-gap/padding/radius accept "var:<number variable>". MODES: modes:{"Theme":"Dark"} sets a collection's variable mode on a frame and its children.
-Example: {"name":"Card","layout":"column","w":320,"padding":24,"gap":12,"fill":"#FFFFFF","radius":16,"shadow":true,"children":[{"text":"Pro plan","size":20,"weight":600},{"text":"Everything you need","color":"#6B7280","w":"fill"},{"layout":"row","gap":8,"align":"center","children":[{"icon":"lucide:check","size":16,"color":"#16A34A"},{"text":"Unlimited projects"}]}]}
-Returns {rootId, ids:{layerName:id}, created, warnings}. The result is selected and zoomed to unless select:false.`,
+    description: BUILD_DESCRIPTION,
     inputSchema: {
       spec: object2({}).passthrough().describe("Root node: {name, layout, children:[...], ...}. Several roots: wrap them in a frame or call build again."),
       parentId: string2().optional().describe("Parent frame (default: current page)"),
@@ -30356,7 +32076,7 @@ ${f.content}`).join(`
       const single = files.length === 1 && /\.[a-z0-9]+$/i.test(args.path);
       const written = [];
       for (const f of files) {
-        const target = single ? args.path : join8(args.path, f.path);
+        const target = single ? args.path : join9(args.path, f.path);
         written.push({ format: f.format, path: target, status: await writeIfChanged(target, f.content) });
       }
       return ok({ counts, files: written, ...warnings.length ? { warnings } : {} });
@@ -30394,7 +32114,7 @@ ${f.content}`).join(`
     const bytes = Buffer.from(r.bytesB64, "base64");
     const info = imageInfo(bytes);
     const ext = r.format === "JPG" ? "jpg" : "png";
-    const path = join8(OUT_DIR, `${safeName(r.name)}-${safeName(r.nodeId)}-${Date.now()}.${ext}`);
+    const path = join9(OUT_DIR, `${safeName(r.name)}-${safeName(r.nodeId)}-${Date.now()}.${ext}`);
     await writeFile(path, bytes);
     const meta = { path, nodeId: r.nodeId, name: r.name, width: info?.width, height: info?.height, bytes: bytes.length };
     const content = [{ type: "text", text: json(meta) }];
@@ -30421,7 +32141,7 @@ ${f.content}`).join(`
     const diff = await bridge.request("compare_images", { actual: shot.bytesB64, reference: Buffer.from(refBytes).toString("base64"), referenceMime: info.mime, threshold: args.threshold, sideBySide: !!args.returnImage }, 90000);
     const pct = (v) => Math.round(v * 1e4) / 100;
     const toLayer = (v, axis) => Math.round((v / shot.scale + shot.offset[axis]) * 10) / 10;
-    const heatmapPath = join8(OUT_DIR, `compare-${safeName(shot.name)}-${Date.now()}.png`);
+    const heatmapPath = join9(OUT_DIR, `compare-${safeName(shot.name)}-${Date.now()}.png`);
     await writeFile(heatmapPath, Buffer.from(diff.heatmap, "base64"));
     const refRatio = diff.reference.width / diff.reference.height;
     const ratio = diff.width / diff.height;
@@ -30495,7 +32215,7 @@ Example: {"url":"https://example.com","viewports":[1440,390]}`,
       const built = await bridge.request("build", { spec: v.spec, images, parentId: args.parentId, x, y, select: false, label: "Web import" }, 120000);
       let reference;
       if (v.screenshot) {
-        reference = join8(OUT_DIR, `import-${safeName(v.title || "page")}-${v.viewport}-${Date.now()}.png`);
+        reference = join9(OUT_DIR, `import-${safeName(v.title || "page")}-${v.viewport}-${Date.now()}.png`);
         await writeFile(reference, v.screenshot);
       }
       frames.push({ viewport: v.viewport, rootId: built.rootId, name: v.spec.name, layers: built.created, size: { width: v.width, height: v.height }, reference });
@@ -30565,7 +32285,7 @@ Links are added to existing interactions unless replace:true; clear:[ids] remove
     }
   }, ({ nodeId, projectPath, framework, styling, name, outDir, write, overwrite }) => track("export_code", `${nodeId ?? "(selection)"} ${projectPath ?? `${framework ?? "html"}/${styling ?? "css"}`}`, async () => {
     const r = await bridge.request("export_tree", { nodeId }, 120000);
-    const dir = join8(OUT_DIR, `export-${safeName(r.tree.name)}-${Date.now()}`);
+    const dir = join9(OUT_DIR, `export-${safeName(r.tree.name)}-${Date.now()}`);
     const finalName = {};
     const assetBytes = {};
     for (const [file, a] of Object.entries(r.assets)) {
@@ -30581,8 +32301,8 @@ Links are added to existing interactions unless replace:true; clear:[ids] remove
     if (projectPath) {
       const plan = planProjectExport(projectPath, tree, assetBytes, { framework, styling, name, outDir });
       for (const f of plan.files) {
-        mkdirSync4(dirname3(join8(dir, f.path)), { recursive: true });
-        writeFileSync4(join8(dir, f.path), typeof f.content === "string" ? f.content : Buffer.from(f.content));
+        mkdirSync6(dirname4(join9(dir, f.path)), { recursive: true });
+        writeFileSync6(join9(dir, f.path), typeof f.content === "string" ? f.content : Buffer.from(f.content));
       }
       const written = write ? writePlan(projectPath, plan.files, !!overwrite) : null;
       const s = plan.stack;
@@ -30607,13 +32327,13 @@ ${f.content}`).join(`
 … truncated: the full code is in ${dir}`;
       return { content: [{ type: "text", text: json(meta) }, { type: "text", text }] };
     }
-    mkdirSync4(join8(dir, "assets"), { recursive: true });
+    mkdirSync6(join9(dir, "assets"), { recursive: true });
     for (const [file, bytes] of Object.entries(assetBytes))
-      writeFileSync4(join8(dir, "assets", file), bytes);
+      writeFileSync6(join9(dir, "assets", file), bytes);
     const fw = framework ?? "html";
     const code = generateCode(tree, { framework: fw, styling: styling ?? "css", assetPath: (f) => `assets/${f}` });
     for (const f of code.files)
-      writeFileSync4(join8(dir, f.path), f.content);
+      writeFileSync6(join9(dir, f.path), f.content);
     warnings.push(...code.warnings);
     const meta = {
       dir,
@@ -30762,9 +32482,119 @@ ${f.content}`).join(`
         return ok({ deleted: args.name });
     }
   }));
+  server.registerTool("export_roblox", {
+    title: "Export a frame to Roblox UI",
+    description: "Turn a Figma frame (default: selection) into Roblox UI that looks the same: a .rbxmx model (a ScreenGui, or a Frame with asRootFrame), an equivalent Luau builder " + `script for execute_luau (creates the UI under PARENT, default StarterGui, replaces a previous copy with the same name, returns the root), and the PNG assets.
+` + "Frames become Frames with UICorner, UIStroke, UIGradient, UIPadding; auto-layout becomes UIListLayout (UIFlexItem for fill, AutomaticSize for hug) or UIGridLayout; " + "constraints become AnchorPoint + UDim2; text becomes TextLabel with FontFace (Inter → Builder Sans…), RichText for mixed styles, UITextSizeConstraint; clickable or " + "*Button layers become TextButton/ImageButton. What Roblox can't draw (vectors, icons, blurs, several fills, radial gradients) is rasterized at 2×; panels whose background " + `can't be native become 9-slice images with their content on top; drop shadows become a 9-slice image behind the panel.
+` + "mode: scale (UDim2 scale everywhere), offset (pixels), hybrid (default: scale for free-positioned layers, pixels inside auto-layout). " + "Assets: with upload:true and ROBLOX_API_KEY + ROBLOX_CREATOR_ID set, pictures are uploaded through Open Cloud and their ids written in; otherwise each asset has a " + "placeholder (rbxassetid://PENDING_n): upload the files with your Roblox Studio tools (e.g. upload_image), replace the placeholders in the Luau, run it with execute_luau and check a Studio screenshot. " + 'Example: {"nodeId":"12:34","mode":"hybrid"}',
+    inputSchema: {
+      nodeId: string2().optional(),
+      mode: _enum(["scale", "offset", "hybrid"]).optional().describe("Default hybrid"),
+      targetResolution: array(number2().int().min(100).max(8000)).length(2).optional().describe("Screen size the UI is designed for, default [1920, 1080]"),
+      rasterize: _enum(["auto", "none", "all"]).optional().describe("auto (default): pictures only where Roblox can't draw it; none: approximate instead; all: every styled layer"),
+      outDir: string2().optional().describe("Folder for the files (default: a new temp folder)"),
+      upload: boolean2().optional().describe("Upload the pictures through Open Cloud (needs ROBLOX_API_KEY and ROBLOX_CREATOR_ID)"),
+      asRootFrame: boolean2().optional().describe("Root is a Frame instead of a ScreenGui"),
+      textScaled: boolean2().optional().describe("TextScaled on labels (UITextSizeConstraint keeps the design size as the maximum)"),
+      fonts: object2({}).passthrough().optional().describe('Figma family → Roblox family or rbxasset URL, e.g. {"Inter":"GothamSSm"}'),
+      parent: string2().optional().describe('Luau expression for the parent, default game:GetService("StarterGui")')
+    }
+  }, (args) => track("export_roblox", `${args.nodeId ?? "(selection)"} ${args.mode ?? "hybrid"}`, async () => {
+    const r = await exportRoblox({ ...args, targetResolution: args.targetResolution, fonts: args.fonts }, { request: (m, p, t) => bridge.request(m, p, t), outDir: OUT_DIR });
+    let luau = r.luau;
+    if (luau.length > MAX_OUTPUT_CHARS)
+      luau = luau.slice(0, MAX_OUTPUT_CHARS) + `
+-- … truncated: the full script is in ${r.result.luau}`;
+    return { content: [{ type: "text", text: json(r.result) }, { type: "text", text: luau }] };
+  }));
+  server.registerTool("comments", {
+    title: "Read and write file comments",
+    description: "Figma comments through the REST API (needs FIGMA_TOKEN; without it, returns how to set one). " + "list: open threads with their replies and the layer each is pinned to (includeResolved for all). " + "post: {message, nodeId?} pinned to a layer (x/y offset inside it), or on the file. reply: {commentId, message}. " + `resolve: Figma's API cannot resolve comments, so this replies "✓ Resolved" (or message) and the user clicks Resolve. delete: {commentId} (your own comments). ` + 'The file is the connected one, or fileUrl. Example: {"action":"post","nodeId":"12:34","message":"Contrast is 2.8:1 here"}',
+    inputSchema: {
+      action: _enum(["list", "post", "reply", "resolve", "delete"]).optional().describe("Default list"),
+      fileUrl: string2().optional().describe("File link or key (default: the connected file)"),
+      nodeId: string2().optional().describe("post: layer to pin the comment to"),
+      x: number2().optional().describe("post: offset inside the layer, px"),
+      y: number2().optional(),
+      message: string2().max(5000).optional(),
+      commentId: string2().optional().describe("reply, resolve, delete"),
+      includeResolved: boolean2().optional().describe("list: include resolved threads")
+    }
+  }, (args) => track("comments", `${args.action ?? "list"} ${args.commentId ?? args.nodeId ?? ""}`, async () => {
+    const { rest, key, session } = await restContext(args.fileUrl);
+    const action = args.action ?? "list";
+    const need = (v, what) => {
+      if (!v)
+        throw new BridgeError(`\`${what}\` is required for ${action}.`, "BAD_ARGS");
+      return v;
+    };
+    if (action === "list") {
+      const threads = threadComments(await rest.comments(key), !!args.includeResolved);
+      const names = await layerNames(session, threads.map((t) => t.nodeId).filter((x) => !!x));
+      return ok({
+        fileKey: key,
+        open: threads.filter((t) => !t.resolvedAt).length,
+        threads: threads.map((t) => t.nodeId && names[t.nodeId] ? { ...t, layer: names[t.nodeId] } : t)
+      });
+    }
+    if (action === "post") {
+      const c = await rest.postComment(key, need(args.message, "message"), { nodeId: args.nodeId, offset: args.nodeId ? { x: args.x ?? 0, y: args.y ?? 0 } : undefined });
+      return ok({ posted: c.id, nodeId: args.nodeId ?? null });
+    }
+    if (action === "reply") {
+      const c = await rest.postComment(key, need(args.message, "message"), { replyTo: need(args.commentId, "commentId") });
+      return ok({ replied: c.id, to: args.commentId });
+    }
+    if (action === "resolve") {
+      const c = await rest.postComment(key, args.message ?? "✓ Resolved", { replyTo: need(args.commentId, "commentId") });
+      return ok({ replied: c.id, to: args.commentId, note: "Figma's REST API has no way to resolve a comment: a reply says it is resolved; ask the user to click Resolve." });
+    }
+    await rest.deleteComment(key, need(args.commentId, "commentId"));
+    return ok({ deleted: args.commentId });
+  }));
+  server.registerTool("versions", {
+    title: "File versions and what changed",
+    description: "Version history through the REST API (needs FIGMA_TOKEN). list: saved versions (id, label, description, author, date). " + "diff: {versionId} compares that version with now (or with toVersionId) and lists layers added, removed and changed (text, size, position, fill, visibility, type), matched by their name path. " + "Scope: nodeId, else the current page of the connected file, else every page. The file is the connected one, or fileUrl. " + 'Example: {"action":"diff","versionId":"1234567890"}',
+    inputSchema: {
+      action: _enum(["list", "diff"]).optional().describe("Default list"),
+      fileUrl: string2().optional().describe("File link or key (default: the connected file)"),
+      versionId: string2().optional().describe("diff: the older version"),
+      toVersionId: string2().optional().describe("diff: the newer version (default: now)"),
+      nodeId: string2().optional().describe("diff: only this layer and its children"),
+      limit: number2().int().min(1).max(200).optional().describe("list: max versions, default 30; diff: max items per list, default 200")
+    }
+  }, (args) => track("versions", `${args.action ?? "list"} ${args.versionId ?? ""}`, async () => {
+    const { rest, key, session } = await restContext(args.fileUrl);
+    if ((args.action ?? "list") === "list") {
+      const list = await rest.versions(key, args.limit ?? 30);
+      return ok({
+        fileKey: key,
+        versions: list.map((v) => ({ id: v.id, createdAt: v.created_at, ...v.label ? { label: v.label } : {}, ...v.description ? { description: v.description } : {}, author: v.user?.handle }))
+      });
+    }
+    if (!args.versionId)
+      throw new BridgeError('`versionId` is required for diff: call versions {action:"list"} first.', "BAD_ARGS");
+    let ids;
+    if (args.nodeId)
+      ids = [args.nodeId];
+    else if (session?.pageId)
+      ids = [session.pageId];
+    else
+      ids = [...new Set([...await rest.pages(key, args.versionId), ...await rest.pages(key, args.toVersionId)].map((p) => p.id))];
+    const [before, after] = await Promise.all([rest.nodes(key, ids, args.versionId), rest.nodes(key, ids, args.toVersionId)]);
+    const empty = (id, name) => ({ id, name, type: "PAGE", children: [] });
+    const results = ids.map((id) => {
+      const b = before[id];
+      const a = after[id];
+      const name = (a ?? b)?.name ?? id;
+      const d = diffTrees(b ?? empty(id, name), a ?? empty(id, name), args.limit ?? 200);
+      return { id, name, ...b ? {} : { note: "did not exist in the older version" }, ...a ? {} : { note: "no longer exists" }, ...d };
+    });
+    return ok({ fileKey: key, from: args.versionId, to: args.toVersionId ?? "now", scopes: results });
+  }));
   server.registerTool("list_sessions", {
     title: "List connected Figma files",
-    description: "Figma files that currently have the plugin open, plus bridge status. Needed only when several files are open.",
+    description: "Figma files that currently have the plugin open (with their editor: figma, figjam or slides), plus bridge status. With several files, " + 'select_session picks the default one, or pass file:"<name>" to any tool to target a file for that call only.',
     inputSchema: {}
   }, () => track("list_sessions", "", async () => {
     const sessions = await bridge.sessions().catch(() => []);
@@ -30776,6 +32606,7 @@ ${f.content}`).join(`
         fileName: s.fileName,
         page: s.page,
         pluginVersion: s.version,
+        editor: s.editorType,
         ...s.version && s.version !== version ? { versionMismatch: `Plugin v${s.version}, server v${version}: ask the user to reopen the plugin in Figma, or update it.` } : {},
         connectedSeconds: Math.round((Date.now() - s.connectedAt) / 1000),
         selected: s.id === selected || undefined
@@ -30791,6 +32622,7 @@ ${f.content}`).join(`
     const s = await bridge.select(name);
     return ok({ selected: { id: s.id, fileName: s.fileName, page: s.page } });
   }));
+  registerGuides(server, { instructions: INSTRUCTIONS, buildSpec: BUILD_DESCRIPTION, tools: () => toolDocs });
   await server.connect(new StdioServerTransport);
   log(`Figma Bridge MCP ${version} ready (port ${PORT}, channel ${CHANNEL}, files in ${OUT_DIR})`);
   process.stdin.on("close", shutdown);
@@ -30799,8 +32631,8 @@ ${f.content}`).join(`
 });
 
 // src/cli.ts
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname4, join as join9 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname5, join as join10 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/setup.ts
@@ -30941,9 +32773,9 @@ function parseClients(argv) {
 init_package();
 var PACKAGE = "@clovis500c/figma-bridge";
 var [cmd, ...rest] = process.argv.slice(2);
-var home = homedir2();
-var pluginSource = join9(dirname4(fileURLToPath2(import.meta.url)), "..", "plugin");
-var pluginTarget = join9(home, ".figma-bridge", "plugin");
+var home = homedir3();
+var pluginSource = join10(dirname5(fileURLToPath2(import.meta.url)), "..", "plugin");
+var pluginTarget = join10(home, ".figma-bridge", "plugin");
 var npx = process.platform === "win32" ? { command: "cmd", args: ["/c", "npx", "-y", PACKAGE] } : { command: "npx", args: ["-y", PACKAGE] };
 function plugin() {
   const manifest = installPlugin(pluginSource, pluginTarget);
@@ -30973,7 +32805,7 @@ Figma Bridge setup
       break;
     }
     try {
-      const appData = process.env.APPDATA || join9(home, "AppData", "Roaming");
+      const appData = process.env.APPDATA || join10(home, "AppData", "Roaming");
       printSetup(runSetup({ home, appData, command: npx.command, args: npx.args, clients: parseClients(rest) }), `npx ${PACKAGE} setup`);
     } catch (e) {
       console.log(yellow(e.message));