@clovis500c/figma-bridge 1.5.0 → 1.12.0

package/plugin/code.js

@@ -255,6 +255,67 @@
       p = p.parent;
     return p;
   }
+  function toLab(c) {
+    const lin = function(v) {
+      return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+    };
+    const r = lin(c.r);
+    const g = lin(c.g);
+    const b = lin(c.b);
+    const x = (0.4124564 * r + 0.3575761 * g + 0.1804375 * b) / 0.95047;
+    const y = 0.2126729 * r + 0.7151522 * g + 0.072175 * b;
+    const z = (0.0193339 * r + 0.119192 * g + 0.9503041 * b) / 1.08883;
+    const f = function(t) {
+      return t > 216 / 24389 ? Math.cbrt(t) : (24389 / 27 * t + 16) / 116;
+    };
+    return [116 * f(y) - 16, 500 * (f(x) - f(y)), 200 * (f(y) - f(z))];
+  }
+  function deltaE(a, b) {
+    const l1 = toLab(a);
+    const l2 = toLab(b);
+    const rad = Math.PI / 180;
+    const c1 = Math.sqrt(l1[1] * l1[1] + l1[2] * l1[2]);
+    const c2 = Math.sqrt(l2[1] * l2[1] + l2[2] * l2[2]);
+    const cm = (c1 + c2) / 2;
+    const g = 0.5 * (1 - Math.sqrt(Math.pow(cm, 7) / (Math.pow(cm, 7) + Math.pow(25, 7))));
+    const a1 = l1[1] * (1 + g);
+    const a2 = l2[1] * (1 + g);
+    const cp1 = Math.sqrt(a1 * a1 + l1[2] * l1[2]);
+    const cp2 = Math.sqrt(a2 * a2 + l2[2] * l2[2]);
+    const hue = function(x, y) {
+      if (x === 0 && y === 0)
+        return 0;
+      const h = Math.atan2(y, x) / rad;
+      return h < 0 ? h + 360 : h;
+    };
+    const h1 = hue(a1, l1[2]);
+    const h2 = hue(a2, l2[2]);
+    const dl = l2[0] - l1[0];
+    const dc = cp2 - cp1;
+    let dh = 0;
+    if (cp1 * cp2 !== 0) {
+      dh = h2 - h1;
+      if (dh > 180)
+        dh -= 360;
+      else if (dh < -180)
+        dh += 360;
+    }
+    const dH = 2 * Math.sqrt(cp1 * cp2) * Math.sin(dh / 2 * rad);
+    const lm = (l1[0] + l2[0]) / 2;
+    const cpm = (cp1 + cp2) / 2;
+    let hm = h1 + h2;
+    if (cp1 * cp2 !== 0) {
+      if (Math.abs(h1 - h2) > 180)
+        hm += h1 + h2 < 360 ? 360 : -360;
+      hm /= 2;
+    }
+    const t = 1 - 0.17 * Math.cos((hm - 30) * rad) + 0.24 * Math.cos(2 * hm * rad) + 0.32 * Math.cos((3 * hm + 6) * rad) - 0.2 * Math.cos((4 * hm - 63) * rad);
+    const sl = 1 + 0.015 * Math.pow(lm - 50, 2) / Math.sqrt(20 + Math.pow(lm - 50, 2));
+    const sc = 1 + 0.045 * cpm;
+    const sh = 1 + 0.015 * cpm * t;
+    const rt = -2 * Math.sqrt(Math.pow(cpm, 7) / (Math.pow(cpm, 7) + Math.pow(25, 7))) * Math.sin(60 * Math.exp(-Math.pow((hm - 275) / 25, 2)) * rad);
+    return Math.sqrt(Math.pow(dl / sl, 2) + Math.pow(dc / sc, 2) + Math.pow(dH / sh, 2) + rt * (dc / sc) * (dH / sh));
+  }
 
   // plugin/lib/annotate.ts
   var COLORS = ["yellow", "orange", "red", "pink", "violet", "blue", "teal", "green"];
@@ -357,11 +418,596 @@
     return { count: out.length, nodes: out };
   }
 
+  // plugin/lib/health.ts
+  var MAX_NODES = 20000;
+  var MAX_ISSUES = 100;
+  var WEIGHTS2 = { tokens: 25, contrast: 20, typography: 15, components: 15, styles: 15, naming: 10 };
+  var NUMBER_FIELDS = ["itemSpacing", "counterAxisSpacing", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft"];
+  var RADIUS_FIELDS = ["topLeftRadius", "topRightRadius", "bottomRightRadius", "bottomLeftRadius"];
+  async function scopeNodes(p, wholeFile, requestId) {
+    let roots;
+    let label;
+    if (p.nodeId) {
+      const n = await getNode(p.nodeId);
+      roots = [n];
+      label = n.name;
+    } else if (wholeFile) {
+      await figma.loadAllPagesAsync();
+      roots = figma.root.children.slice();
+      label = "the whole file";
+    } else if (figma.currentPage.selection.length) {
+      roots = figma.currentPage.selection.slice();
+      label = "the selection";
+    } else {
+      roots = figma.currentPage.children.slice();
+      label = "page " + figma.currentPage.name;
+    }
+    const nodes = [];
+    let truncated = false;
+    const walk = function(n) {
+      if (nodes.length >= MAX_NODES) {
+        truncated = true;
+        return;
+      }
+      if (n.type !== "PAGE" && n.type !== "DOCUMENT")
+        nodes.push(n);
+      if (n.type === "INSTANCE" || !("children" in n))
+        return;
+      if (n.type === "PAGE" && n.name === "⟲ Bridge checkpoints")
+        return;
+      for (let i = 0;i < n.children.length; i++)
+        walk(n.children[i]);
+    };
+    for (let i = 0;i < roots.length; i++) {
+      checkCancelled(requestId);
+      walk(roots[i]);
+    }
+    return { nodes, truncated, label };
+  }
+  function visibleSolids(paints) {
+    if (!paints || paints === figma.mixed)
+      return [];
+    return paints.filter(function(pt) {
+      return pt.visible !== false && pt.type === "SOLID";
+    });
+  }
+  function score(good, total) {
+    return total ? Math.round(good / total * 100) : 100;
+  }
+  function convention(name) {
+    const seg = name.split("/").pop() || name;
+    if (/^[a-z0-9]+(-[a-z0-9]+)+$/.test(seg))
+      return "kebab-case";
+    if (/^[a-z0-9]+(_[a-z0-9]+)+$/.test(seg))
+      return "snake_case";
+    if (/^[a-z]+[A-Z][A-Za-z0-9]*$/.test(seg))
+      return "camelCase";
+    if (/^[A-Z][a-z0-9]*( [A-Z0-9][a-z0-9]*)*$/.test(seg))
+      return "Title Case";
+    if (/^[a-z0-9]+$/.test(seg))
+      return "lowercase";
+    return "mixed";
+  }
+  function namingConsistency(names, what, issues) {
+    const counts = {};
+    const multiWord = [];
+    for (let i = 0;i < names.length; i++) {
+      const c = convention(names[i]);
+      if (c === "lowercase")
+        continue;
+      counts[c] = (counts[c] || 0) + 1;
+      multiWord.push(names[i]);
+    }
+    const keys = Object.keys(counts).sort(function(a, b) {
+      return counts[b] - counts[a];
+    });
+    const main = keys[0] || "lowercase";
+    const off = multiWord.filter(function(n) {
+      return convention(n) !== main;
+    });
+    for (let i = 0;i < Math.min(off.length, 5); i++)
+      issues.push({ category: "naming", message: what + ' "' + off[i] + '" is not ' + main + " like most others" });
+    return { score: score(multiWord.length - off.length, multiWord.length), convention: main };
+  }
+  function paintKey(paints) {
+    return JSON.stringify(paints.map(function(pt) {
+      if (pt.type === "SOLID")
+        return toHex(pt.color, pt.opacity) + (pt.boundVariables && pt.boundVariables.color ? "@" + pt.boundVariables.color.id : "");
+      if (pt.gradientStops)
+        return pt.type + pt.gradientStops.map(function(s) {
+          return toHex(s.color) + round(s.position);
+        });
+      return pt.type + (pt.imageHash || "");
+    }));
+  }
+  async function designSystemHealth(p, requestId) {
+    const scope = await scopeNodes(p, !p.nodeId, requestId);
+    const nodes = scope.nodes;
+    const issues = [];
+    const add = function(category, message, n) {
+      if (issues.length < MAX_ISSUES * 3)
+        issues.push(n ? { category, message, nodeId: n.id, name: n.name } : { category, message });
+    };
+    const styles = await localStyles();
+    const vars = await localVariables();
+    const components = await localComponents();
+    const componentNames = {};
+    for (let i = 0;i < components.length; i++)
+      componentNames[components[i].name] = true;
+    const used = {};
+    const use = function(id) {
+      if (typeof id === "string" && id)
+        used[id] = (used[id] || 0) + 1;
+    };
+    let colorTotal = 0;
+    let colorBound = 0;
+    let numberTotal = 0;
+    let numberBound = 0;
+    let textTotal = 0;
+    let textStyled = 0;
+    let contrastTotal = 0;
+    let contrastOk = 0;
+    let layerTotal = 0;
+    let layerDefault = 0;
+    let instanceCount = 0;
+    let overridden = 0;
+    let detached = 0;
+    const pageBg = pageBackground();
+    for (let i = 0;i < nodes.length; i++) {
+      if (i % 500 === 0)
+        checkCancelled(requestId);
+      const n = nodes[i];
+      const bound = n.boundVariables || {};
+      const keys = Object.keys(bound);
+      for (let k = 0;k < keys.length; k++) {
+        const b = bound[keys[k]];
+        if (Array.isArray(b))
+          for (let j = 0;j < b.length; j++)
+            use(b[j] && b[j].id);
+        else if (b && b.id)
+          use(b.id);
+      }
+      ["fillStyleId", "strokeStyleId", "effectStyleId", "textStyleId"].forEach(function(f) {
+        if (f in n)
+          use(n[f]);
+      });
+      if (n.type === "INSTANCE") {
+        instanceCount++;
+        const fields = (n.overrides || []).reduce(function(sum, o) {
+          return sum + o.overriddenFields.length;
+        }, 0);
+        if (fields > 12) {
+          overridden++;
+          add("components", "Instance with " + fields + " overridden properties: consider a variant", n);
+        }
+        continue;
+      }
+      if ((n.type === "FRAME" || n.type === "GROUP") && (componentNames[n.name] || /^[^=,]+=[^=,]+(, [^=,]+=[^=,]+)*$/.test(n.name))) {
+        detached++;
+        add("components", 'Frame named like a component ("' + n.name + '"): probably a detached instance', n);
+      }
+      const fillStyled = typeof n.fillStyleId === "string" && n.fillStyleId !== "";
+      const solids = fillStyled ? [] : visibleSolids(n.fills);
+      for (let k = 0;k < solids.length; k++) {
+        colorTotal++;
+        if (solids[k].boundVariables && solids[k].boundVariables.color)
+          colorBound++;
+        else
+          add("tokens", "Hard-coded color " + toHex(solids[k].color, solids[k].opacity), n);
+      }
+      const strokeStyled = typeof n.strokeStyleId === "string" && n.strokeStyleId !== "";
+      const strokes = strokeStyled ? [] : visibleSolids(n.strokes);
+      for (let k = 0;k < strokes.length; k++) {
+        colorTotal++;
+        if (strokes[k].boundVariables && strokes[k].boundVariables.color)
+          colorBound++;
+      }
+      if (fillStyled) {
+        colorTotal++;
+        colorBound++;
+      }
+      if (n.layoutMode && n.layoutMode !== "NONE") {
+        for (let k = 0;k < NUMBER_FIELDS.length; k++) {
+          const f = NUMBER_FIELDS[k];
+          if (f === "counterAxisSpacing" && n.layoutWrap !== "WRAP")
+            continue;
+          if (!n[f])
+            continue;
+          numberTotal++;
+          if (bound[f])
+            numberBound++;
+        }
+      }
+      if ("topLeftRadius" in n && n.type !== "TEXT") {
+        for (let k = 0;k < RADIUS_FIELDS.length; k++) {
+          if (!n[RADIUS_FIELDS[k]])
+            continue;
+          numberTotal++;
+          if (bound[RADIUS_FIELDS[k]])
+            numberBound++;
+        }
+      }
+      if (n.type === "TEXT") {
+        textTotal++;
+        if (typeof n.textStyleId === "string" && n.textStyleId)
+          textStyled++;
+        else if (n.textStyleId === figma.mixed)
+          textStyled += 0.5;
+        else
+          add("typography", "Text without a text style (" + (n.fontName !== figma.mixed ? n.fontName.family + " " + n.fontName.style : "mixed fonts") + ", " + (n.fontSize !== figma.mixed ? round(n.fontSize) : "mixed") + " px)", n);
+        const c = n.visible ? textContrast(n, pageBg) : null;
+        if (c) {
+          contrastTotal++;
+          if (c.ratio >= c.min)
+            contrastOk++;
+          else
+            add("contrast", "Contrast " + round(c.ratio) + ":1 is below " + c.min + ":1", n);
+        }
+      } else if (n.type !== "COMPONENT" && n.type !== "COMPONENT_SET" && n.type !== "SECTION") {
+        layerTotal++;
+        if (DEFAULT_NAME.test(n.name)) {
+          layerDefault++;
+          add("naming", "Default layer name", n);
+        }
+      }
+    }
+    const styleTotal = styles.paint.length + styles.text.length + styles.effect.length;
+    let styleProblems = 0;
+    const seen = {};
+    const dup = function(key, name, kind) {
+      if (seen[key]) {
+        styleProblems++;
+        add("styles", kind + ' style "' + name + '" duplicates "' + seen[key] + '"');
+      } else
+        seen[key] = name;
+    };
+    for (let i = 0;i < styles.paint.length; i++)
+      dup("p" + paintKey(styles.paint[i].paints), styles.paint[i].name, "Color");
+    for (let i = 0;i < styles.text.length; i++) {
+      const s = styles.text[i];
+      dup("t" + JSON.stringify([s.fontName, s.fontSize, s.lineHeight, s.letterSpacing, s.textCase, s.textDecoration]), s.name, "Text");
+    }
+    for (let i = 0;i < styles.effect.length; i++)
+      dup("e" + JSON.stringify(styles.effect[i].effects), styles.effect[i].name, "Effect");
+    const wholeFile = !p.nodeId;
+    if (wholeFile) {
+      const all = styles.paint.concat(styles.text, styles.effect);
+      for (let i = 0;i < all.length; i++) {
+        if (used[all[i].id])
+          continue;
+        styleProblems++;
+        add("styles", 'Style "' + all[i].name + '" is not used in this file');
+      }
+    }
+    for (let i = 0;i < vars.vars.length; i++) {
+      const v = vars.vars[i];
+      const modes = Object.keys(v.valuesByMode);
+      for (let k = 0;k < modes.length; k++) {
+        const val = v.valuesByMode[modes[k]];
+        if (val && val.type === "VARIABLE_ALIAS")
+          use(val.id);
+      }
+    }
+    for (let i = 0;i < styles.paint.length; i++) {
+      const ps = styles.paint[i].paints;
+      for (let k = 0;k < ps.length; k++)
+        if (ps[k].boundVariables && ps[k].boundVariables.color)
+          use(ps[k].boundVariables.color.id);
+    }
+    let unusedVars = 0;
+    if (wholeFile) {
+      for (let i = 0;i < vars.vars.length; i++) {
+        if (used[vars.vars[i].id])
+          continue;
+        unusedVars++;
+        if (unusedVars <= 10)
+          add("styles", 'Variable "' + vars.vars[i].name + '" is not used in this file');
+      }
+    }
+    let unusedComponents = 0;
+    if (wholeFile) {
+      for (let i = 0;i < Math.min(components.length, 300); i++) {
+        const c = components[i];
+        const parts = c.type === "COMPONENT_SET" ? c.children : [c];
+        let count = 0;
+        for (let k = 0;k < parts.length && !count; k++)
+          count += (await parts[k].getInstancesAsync()).length;
+        if (!count) {
+          unusedComponents++;
+          add("styles", 'Component "' + c.name + '" has no instances');
+        }
+      }
+    }
+    const varNames = vars.vars.map(function(v) {
+      return v.name;
+    });
+    const styleNames = styles.paint.concat(styles.text, styles.effect).map(function(s) {
+      return s.name;
+    });
+    const naming = namingConsistency(varNames.concat(styleNames), "Token", issues);
+    const categories = {
+      tokens: { score: score(colorBound + numberBound, colorTotal + numberTotal), colors: { bound: colorBound, total: colorTotal }, numbers: { bound: numberBound, total: numberTotal } },
+      contrast: { score: score(contrastOk, contrastTotal), passing: contrastOk, total: contrastTotal },
+      typography: { score: score(textStyled, textTotal), styled: Math.floor(textStyled), total: textTotal },
+      components: {
+        score: Math.max(0, 100 - Math.round((detached + overridden * 0.5) / Math.max(1, instanceCount + detached) * 100)),
+        instances: instanceCount,
+        detachedSuspects: detached,
+        heavilyOverridden: overridden,
+        unused: wholeFile ? unusedComponents : undefined
+      },
+      styles: {
+        score: score(styleTotal + vars.vars.length + components.length - styleProblems - unusedVars - unusedComponents, styleTotal + vars.vars.length + components.length),
+        styles: styleTotal,
+        variables: vars.vars.length,
+        problems: styleProblems + unusedVars + unusedComponents
+      },
+      naming: {
+        score: Math.round((score(layerTotal - layerDefault, layerTotal) + naming.score) / 2),
+        defaultLayerNames: layerDefault,
+        layers: layerTotal,
+        tokenConvention: naming.convention
+      }
+    };
+    let total = 0;
+    let weight = 0;
+    const names = Object.keys(WEIGHTS2);
+    for (let i = 0;i < names.length; i++) {
+      total += categories[names[i]].score * WEIGHTS2[names[i]];
+      weight += WEIGHTS2[names[i]];
+    }
+    const picked = [];
+    for (let pass = 0;picked.length < MAX_ISSUES && pass < MAX_ISSUES; pass++) {
+      let added = false;
+      for (let c = 0;c < names.length && picked.length < MAX_ISSUES; c++) {
+        const list = issues.filter(function(x) {
+          return x.category === names[c];
+        });
+        if (list[pass]) {
+          picked.push(list[pass]);
+          added = true;
+        }
+      }
+      if (!added)
+        break;
+    }
+    return {
+      scope: scope.label,
+      score: Math.round(total / weight),
+      categories,
+      issues: picked,
+      totalIssues: issues.length,
+      nodesChecked: nodes.length,
+      truncated: scope.truncated,
+      hint: "audit {fix:true} binds raw colors and numbers to matching variables, applies matching text styles and renames default layer names."
+    };
+  }
+  function resolved(v, byId, collections, depth) {
+    const col = collections[v.variableCollectionId];
+    if (!col)
+      return null;
+    const raw = v.valuesByMode[col.defaultModeId];
+    if (raw && raw.type === "VARIABLE_ALIAS") {
+      const t = byId[raw.id];
+      return t && (depth || 0) < 10 ? resolved(t, byId, collections, (depth || 0) + 1) : null;
+    }
+    return raw;
+  }
+  function scoped(v, wanted) {
+    const s = v.scopes || [];
+    if (!s.length || s.indexOf("ALL_SCOPES") !== -1)
+      return true;
+    for (let i = 0;i < wanted.length; i++)
+      if (s.indexOf(wanted[i]) !== -1)
+        return true;
+    return false;
+  }
+  var FILL_SCOPES = { TEXT: ["ALL_FILLS", "TEXT_FILL"], FRAME: ["ALL_FILLS", "FRAME_FILL"], COMPONENT: ["ALL_FILLS", "FRAME_FILL"], SECTION: ["ALL_FILLS", "FRAME_FILL"] };
+  async function autoFix(p, requestId) {
+    const all = ["colors", "numbers", "textStyles", "names"];
+    const fixes = Array.isArray(p.fixes) && p.fixes.length ? p.fixes : all;
+    for (let i = 0;i < fixes.length; i++)
+      if (all.indexOf(fixes[i]) === -1)
+        throw codeError('Unknown fix "' + fixes[i] + '" (use ' + all.join(", ") + ")", "BAD_ARGS");
+    const scope = await scopeNodes(p, false, requestId);
+    const vars = await localVariables();
+    const byId = {};
+    const collections = {};
+    for (let i = 0;i < vars.vars.length; i++)
+      byId[vars.vars[i].id] = vars.vars[i];
+    for (let i = 0;i < vars.collections.length; i++)
+      collections[vars.collections[i].id] = vars.collections[i];
+    const colorVars = [];
+    const numberVars = [];
+    for (let i = 0;i < vars.vars.length; i++) {
+      const v = vars.vars[i];
+      const value = resolved(v, byId, collections);
+      if (v.resolvedType === "COLOR" && value && typeof value === "object")
+        colorVars.push({ v, rgba: value });
+      if (v.resolvedType === "FLOAT" && typeof value === "number")
+        numberVars.push({ v, num: value });
+    }
+    const changes = [];
+    const counts = { colors: 0, numbers: 0, textStyles: 0, names: 0 };
+    const record = function(n, fix, from, to) {
+      counts[fix]++;
+      if (changes.length < 200)
+        changes.push({ nodeId: n.id, name: n.name, fix, from, to });
+    };
+    const matchColor = function(n, paint, scopes) {
+      const alpha = paint.opacity === undefined ? 1 : paint.opacity;
+      const ranked = colorVars.filter(function(c) {
+        return scoped(c.v, scopes) && Math.abs((c.rgba.a === undefined ? 1 : c.rgba.a) - alpha) < 0.02;
+      }).map(function(c) {
+        return { c, d: deltaE(c.rgba, paint.color) };
+      }).filter(function(x) {
+        return x.d < 2;
+      }).sort(function(a, b) {
+        return a.d - b.d;
+      });
+      for (let i = 0;i < ranked.length; i++) {
+        try {
+          const r = ranked[i].c.v.resolveForConsumer(n).value;
+          if (r && typeof r === "object" && deltaE(r, paint.color) < 2)
+            return ranked[i].c.v;
+        } catch (e) {}
+      }
+      return null;
+    };
+    const matchNumber = function(value, scopes, hint) {
+      const hits = numberVars.filter(function(c) {
+        return Math.abs(c.num - value) < 0.01 && scoped(c.v, scopes);
+      });
+      hits.sort(function(a, b) {
+        return (hint.test(b.v.name) ? 1 : 0) - (hint.test(a.v.name) ? 1 : 0);
+      });
+      return hits.length ? hits[0].v : null;
+    };
+    const textStyles = fixes.indexOf("textStyles") !== -1 ? (await localStyles()).text : [];
+    for (let i = 0;i < scope.nodes.length; i++) {
+      if (i % 200 === 0)
+        checkCancelled(requestId);
+      const n = scope.nodes[i];
+      if (n.type === "INSTANCE" || n.locked)
+        continue;
+      const bound = n.boundVariables || {};
+      if (fixes.indexOf("colors") !== -1) {
+        const fields = ["fills", "strokes"];
+        for (let f = 0;f < fields.length; f++) {
+          const field = fields[f];
+          if (!(field in n) || n[field] === figma.mixed)
+            continue;
+          if (field === "fills" && n.fillStyleId || field === "strokes" && n.strokeStyleId)
+            continue;
+          const paints = n[field].slice();
+          let changed = false;
+          for (let k = 0;k < paints.length; k++) {
+            const pt = paints[k];
+            if (pt.type !== "SOLID" || pt.visible === false || pt.boundVariables && pt.boundVariables.color)
+              continue;
+            const v = matchColor(n, pt, field === "strokes" ? ["STROKE_COLOR"] : FILL_SCOPES[n.type] || ["ALL_FILLS", "SHAPE_FILL"]);
+            if (!v)
+              continue;
+            paints[k] = figma.variables.setBoundVariableForPaint(pt, "color", v);
+            changed = true;
+            record(n, "colors", field + " " + toHex(pt.color, pt.opacity), "var:" + v.name);
+          }
+          if (changed)
+            n[field] = paints;
+        }
+      }
+      if (fixes.indexOf("numbers") !== -1) {
+        const fields = [];
+        if (n.layoutMode && n.layoutMode !== "NONE") {
+          for (let k = 0;k < NUMBER_FIELDS.length; k++)
+            if (NUMBER_FIELDS[k] !== "counterAxisSpacing" || n.layoutWrap === "WRAP")
+              fields.push(NUMBER_FIELDS[k]);
+        }
+        if ("topLeftRadius" in n && n.type !== "TEXT")
+          for (let k = 0;k < RADIUS_FIELDS.length; k++)
+            fields.push(RADIUS_FIELDS[k]);
+        for (let k = 0;k < fields.length; k++) {
+          const f = fields[k];
+          const value = n[f];
+          if (typeof value !== "number" || !value || bound[f])
+            continue;
+          const radius = f.indexOf("Radius") !== -1;
+          const v = matchNumber(value, radius ? ["CORNER_RADIUS"] : ["GAP"], radius ? /radius|corner|round/i : /spac|gap|pad/i);
+          if (!v)
+            continue;
+          try {
+            n.setBoundVariable(f, v);
+            record(n, "numbers", f + " " + round(value), "var:" + v.name);
+          } catch (e) {}
+        }
+      }
+      if (n.type === "TEXT" && textStyles.length && !n.textStyleId && n.fontName !== figma.mixed && n.fontSize !== figma.mixed && n.lineHeight !== figma.mixed && n.letterSpacing !== figma.mixed) {
+        for (let k = 0;k < textStyles.length; k++) {
+          const s = textStyles[k];
+          if (s.fontName.family === n.fontName.family && s.fontName.style === n.fontName.style && Math.abs(s.fontSize - n.fontSize) < 0.01 && JSON.stringify(s.lineHeight) === JSON.stringify(n.lineHeight) && s.letterSpacing.unit === n.letterSpacing.unit && Math.abs(s.letterSpacing.value - n.letterSpacing.value) < 0.01) {
+            try {
+              await loadFont(s.fontName);
+              await n.setTextStyleIdAsync(s.id);
+              record(n, "textStyles", n.fontName.family + " " + n.fontName.style + " " + round(n.fontSize), "style:" + s.name);
+            } catch (e) {}
+            break;
+          }
+        }
+      }
+      if (fixes.indexOf("names") !== -1 && n.type !== "TEXT" && DEFAULT_NAME.test(n.name)) {
+        const name = nameFromContent(n);
+        if (name && name !== n.name) {
+          const from = n.name;
+          n.name = name;
+          record(n, "names", from, name);
+        }
+      }
+    }
+    return { scope: scope.label, fixed: counts, changes, truncated: scope.truncated || changes.length >= 200 };
+  }
+  function firstText(n, depth) {
+    if (n.type === "TEXT")
+      return n.characters;
+    if (depth > 3 || !("children" in n))
+      return "";
+    for (let i = 0;i < n.children.length; i++) {
+      if (n.children[i].visible === false)
+        continue;
+      const t = firstText(n.children[i], depth + 1);
+      if (t.trim())
+        return t;
+    }
+    return "";
+  }
+  function hasImage(n) {
+    return "fills" in n && n.fills !== figma.mixed && n.fills.some(function(f) {
+      return f.type === "IMAGE" && f.visible !== false;
+    });
+  }
+  function vectorOnly(n) {
+    if (n.type === "VECTOR" || n.type === "BOOLEAN_OPERATION" || n.type === "STAR" || n.type === "POLYGON")
+      return true;
+    if (!("children" in n) || !n.children.length || n.type === "TEXT")
+      return false;
+    for (let i = 0;i < n.children.length; i++)
+      if (!vectorOnly(n.children[i]))
+        return false;
+    return true;
+  }
+  function nameFromContent(n) {
+    if (hasImage(n))
+      return "Image";
+    if (n.type === "VECTOR" || (n.type === "GROUP" || n.type === "FRAME") && vectorOnly(n))
+      return "Icon";
+    const text = firstText(n, 0).split(`
+`)[0].trim();
+    if (text)
+      return text.length > 32 ? text.slice(0, 31) + "…" : text;
+    if (n.layoutMode === "HORIZONTAL")
+      return "Row";
+    if (n.layoutMode === "VERTICAL")
+      return "Column";
+    if (n.layoutMode === "GRID")
+      return "Grid";
+    return null;
+  }
+
   // plugin/lib/audit.ts
-  var MAX_NODES = 5000;
-  var MAX_ISSUES = 120;
+  var MAX_NODES2 = 5000;
+  var MAX_ISSUES2 = 120;
   var DEFAULT_NAME = /^(Frame|Rectangle|Ellipse|Group|Vector|Text|Line|Polygon|Star|Component|Instance|Section|Image)( \d+)?$/;
-  async function audit(p) {
+  async function audit(p, _timeoutMs, requestId) {
+    if (p.fix === true || Array.isArray(p.fixes) && p.fixes.length) {
+      const fixed = await autoFix(p, requestId);
+      invalidateCaches();
+      const after = p.scope === "design-system" ? await designSystemHealth(p, requestId) : await lint(p);
+      return Object.assign({ fixed: fixed.fixed, changes: fixed.changes, fixScope: fixed.scope }, after);
+    }
+    if (p.scope === "design-system")
+      return designSystemHealth(p, requestId);
+    return lint(p);
+  }
+  async function lint(p) {
     let roots;
     if (p.nodeId)
       roots = [await getNode(p.nodeId)];
@@ -380,11 +1026,11 @@
       if (only && only.indexOf(rule) === -1)
         return;
       counts[rule] = (counts[rule] || 0) + 1;
-      if (issues.length < MAX_ISSUES)
+      if (issues.length < MAX_ISSUES2)
         issues.push({ rule, severity, nodeId: n.id, name: n.name, message });
     };
     const visit = function(n, clipBox) {
-      if (visited >= MAX_NODES)
+      if (visited >= MAX_NODES2)
         return;
       visited++;
       if (n.visible === false)
@@ -455,7 +1101,7 @@
       fonts: familyList,
       fontSizes: sizeList,
       issues,
-      truncated: visited >= MAX_NODES || issues.length >= MAX_ISSUES
+      truncated: visited >= MAX_NODES2 || issues.length >= MAX_ISSUES2
     };
   }
   function checkText(n, report, families, sizes, pageBg) {
@@ -480,19 +1126,21 @@
       if (tb.x + tb.width > pb.x + pb.width + 1 || tb.x < pb.x - 1)
         report("text-overflow", "warning", n, "Text extends outside its container");
     }
+    const c = textContrast(n, pageBg);
+    if (c && c.ratio < c.min) {
+      report("contrast", c.ratio < c.min - 1.5 ? "error" : "warning", n, "Contrast " + round(c.ratio) + ":1 is below " + c.min + ":1 (WCAG AA" + (c.large ? ", large text" : "") + ")");
+    }
+  }
+  function textContrast(n, pageBg) {
     const fg = solidOf(n.fills);
     if (!fg || n.fontSize === figma.mixed)
-      return;
+      return null;
     const bg = backgroundOf(n, pageBg);
     if (!bg)
-      return;
-    const ratio = contrastRatio(fg, bg);
+      return null;
     const bold = n.fontName !== figma.mixed && /bold|black|heavy|semi/i.test(n.fontName.style);
     const large = n.fontSize >= 24 || bold && n.fontSize >= 18.66;
-    const min = large ? 3 : 4.5;
-    if (ratio < min) {
-      report("contrast", ratio < min - 1.5 ? "error" : "warning", n, "Contrast " + round(ratio) + ":1 is below " + min + ":1 (WCAG AA" + (large ? ", large text" : "") + ")");
-    }
+    return { ratio: contrastRatio(fg, bg), min: large ? 3 : 4.5, large };
   }
   function solidOf(paints) {
     if (!paints || paints === figma.mixed)
@@ -529,6 +1177,186 @@
     return a.x >= b.x - 0.5 && a.y >= b.y - 0.5 && a.x + a.width <= b.x + b.width + 0.5 && a.y + a.height <= b.y + b.height + 0.5;
   }
 
+  // plugin/lib/figjam.ts
+  var EDITORS = { sticky: "figjam", shape: "figjam", connector: "figjam", table: "figjam", codeblock: "figjam", slide: "slides" };
+  var EDITOR_NAMES = { figma: "Figma Design", figjam: "FigJam", slides: "Figma Slides", dev: "Dev Mode" };
+  function requireEditor(type, path) {
+    const wanted = EDITORS[type];
+    if (wanted && figma.editorType !== wanted) {
+      throw codeError(path + ': "' + type + '" needs a ' + EDITOR_NAMES[wanted] + " file; this file is open in " + (EDITOR_NAMES[figma.editorType] || figma.editorType) + ".", "WRONG_EDITOR");
+    }
+  }
+  var STICKY_COLORS = {
+    white: "#FFFFFF",
+    gray: "#E6E6E6",
+    grey: "#E6E6E6",
+    green: "#B3EFBD",
+    teal: "#B3F4EF",
+    blue: "#A8DAFF",
+    violet: "#D3BDFF",
+    purple: "#D3BDFF",
+    pink: "#FFA8DB",
+    red: "#FFB8A8",
+    orange: "#FFD3A8",
+    yellow: "#FFE299"
+  };
+  function solid(color) {
+    const hex = STICKY_COLORS[String(color).toLowerCase()] || color;
+    const c = parseHex(hex);
+    return { type: "SOLID", color: { r: c.r, g: c.g, b: c.b }, opacity: c.a };
+  }
+  async function setSublayerText(sub, text, opts) {
+    const font = sub.fontName;
+    if (font !== figma.mixed)
+      await loadFont(font);
+    else if (sub.characters.length) {
+      const fonts = sub.getRangeAllFontNames(0, sub.characters.length);
+      for (let i = 0;i < fonts.length; i++)
+        await loadFont(fonts[i]);
+    }
+    if (opts && opts.font) {
+      await loadFont(opts.font);
+      sub.fontName = opts.font;
+    }
+    sub.characters = String(text === undefined || text === null ? "" : text);
+    if (opts && typeof opts.size === "number")
+      sub.fontSize = opts.size;
+    if (opts && opts.color)
+      sub.fills = [solid(opts.color)];
+  }
+  async function createSticky(s) {
+    const n = figma.createSticky();
+    if (s.wide)
+      n.isWideWidth = true;
+    if (s.author === false)
+      n.authorVisible = false;
+    if (s.color || s.fill)
+      n.fills = [solid(s.color || s.fill)];
+    await setSublayerText(n.text, s.text);
+    return n;
+  }
+  var SHAPES = {
+    square: "SQUARE",
+    rect: "SQUARE",
+    rectangle: "SQUARE",
+    rounded: "ROUNDED_RECTANGLE",
+    roundedrectangle: "ROUNDED_RECTANGLE",
+    ellipse: "ELLIPSE",
+    circle: "ELLIPSE",
+    diamond: "DIAMOND",
+    decision: "DIAMOND",
+    triangle: "TRIANGLE_UP",
+    triangleup: "TRIANGLE_UP",
+    triangledown: "TRIANGLE_DOWN",
+    parallelogram: "PARALLELOGRAM_RIGHT",
+    parallelogramleft: "PARALLELOGRAM_LEFT",
+    database: "ENG_DATABASE",
+    cylinder: "ENG_DATABASE",
+    queue: "ENG_QUEUE",
+    file: "ENG_FILE",
+    folder: "ENG_FOLDER",
+    trapezoid: "TRAPEZOID",
+    process: "PREDEFINED_PROCESS",
+    subroutine: "PREDEFINED_PROCESS",
+    shield: "SHIELD",
+    document: "DOCUMENT_SINGLE",
+    documents: "DOCUMENT_MULTIPLE",
+    input: "MANUAL_INPUT",
+    hexagon: "HEXAGON",
+    chevron: "CHEVRON",
+    pentagon: "PENTAGON",
+    octagon: "OCTAGON",
+    star: "STAR",
+    plus: "PLUS",
+    arrowleft: "ARROW_LEFT",
+    arrowright: "ARROW_RIGHT",
+    junction: "SUMMING_JUNCTION",
+    or: "OR",
+    speech: "SPEECH_BUBBLE",
+    speechbubble: "SPEECH_BUBBLE",
+    storage: "INTERNAL_STORAGE"
+  };
+  async function createShape(s, path, warnings) {
+    const n = figma.createShapeWithText();
+    const key = String(s.shape || "rounded").toLowerCase().replace(/[^a-z]/g, "");
+    const shape = SHAPES[key] || String(s.shape || "").toUpperCase();
+    try {
+      n.shapeType = shape;
+    } catch (e) {
+      warnings.push(path + ': unknown shape "' + s.shape + '", used a rounded rectangle');
+      n.shapeType = "ROUNDED_RECTANGLE";
+    }
+    const w = typeof s.w === "number" ? s.w : typeof s.width === "number" ? s.width : 0;
+    const h = typeof s.h === "number" ? s.h : typeof s.height === "number" ? s.height : 0;
+    if (w || h)
+      n.resize(w || n.width, h || n.height);
+    if (s.fill !== undefined)
+      n.fills = s.fill === null ? [] : [solid(s.fill)];
+    if (s.stroke !== undefined)
+      n.strokes = s.stroke === null ? [] : [solid(s.stroke)];
+    if (typeof s.strokeWidth === "number")
+      n.strokeWeight = s.strokeWidth;
+    if (s.text !== undefined)
+      await setSublayerText(n.text, s.text, { size: s.size, color: s.color });
+    return n;
+  }
+  async function createTable(s, path) {
+    const rows = Array.isArray(s.rows) ? s.rows : [];
+    if (!rows.length)
+      throw codeError(path + ': a table needs rows:[["Header 1","Header 2"],["a","b"]]', "BAD_ARGS");
+    let cols = 0;
+    for (let i = 0;i < rows.length; i++)
+      cols = Math.max(cols, Array.isArray(rows[i]) ? rows[i].length : 1);
+    const t = figma.createTable(rows.length, cols);
+    for (let r = 0;r < rows.length; r++) {
+      for (let c = 0;c < cols; c++) {
+        const value = Array.isArray(rows[r]) ? rows[r][c] : c === 0 ? rows[r] : "";
+        const cell = t.cellAt(r, c);
+        await setSublayerText(cell.text, value === undefined ? "" : value);
+        if (r === 0 && s.header !== false)
+          cell.fills = [solid(s.headerFill || "#F2F2F2")];
+      }
+    }
+    return t;
+  }
+  var LANGUAGES = ["TYPESCRIPT", "CPP", "RUBY", "CSS", "JAVASCRIPT", "HTML", "JSON", "GRAPHQL", "PYTHON", "GO", "SQL", "SWIFT", "KOTLIN", "RUST", "BASH", "PLAINTEXT", "DART"];
+  var LANGUAGE_ALIASES = { ts: "TYPESCRIPT", tsx: "TYPESCRIPT", js: "JAVASCRIPT", jsx: "JAVASCRIPT", "c++": "CPP", py: "PYTHON", sh: "BASH", shell: "BASH", text: "PLAINTEXT", txt: "PLAINTEXT", golang: "GO", rb: "RUBY" };
+  function createCodeBlock(s) {
+    const n = figma.createCodeBlock();
+    const lang = String(s.language || "plaintext").toLowerCase();
+    const code = LANGUAGE_ALIASES[lang] || lang.toUpperCase();
+    n.codeLanguage = LANGUAGES.indexOf(code) !== -1 ? code : "PLAINTEXT";
+    n.code = String(s.code === undefined ? "" : s.code);
+    return n;
+  }
+  function createSlide() {
+    return figma.createSlide();
+  }
+  var CAPS = { arrow: "ARROW_LINES", triangle: "ARROW_EQUILATERAL", filled: "TRIANGLE_FILLED", diamond: "DIAMOND_FILLED", circle: "CIRCLE_FILLED", none: "NONE" };
+  var LINES = { elbowed: "ELBOWED", elbow: "ELBOWED", straight: "STRAIGHT", curved: "CURVED", curve: "CURVED" };
+  var MAGNETS = ["AUTO", "TOP", "LEFT", "BOTTOM", "RIGHT", "CENTER", "NONE"];
+  async function createConnector(s, fromId, toId) {
+    const n = figma.createConnector();
+    const magnet = function(v) {
+      const m = String(v || "AUTO").toUpperCase();
+      return MAGNETS.indexOf(m) !== -1 ? m : "AUTO";
+    };
+    n.connectorStart = { endpointNodeId: fromId, magnet: magnet(s.fromMagnet) };
+    n.connectorEnd = { endpointNodeId: toId, magnet: magnet(s.toMagnet) };
+    n.connectorLineType = LINES[String(s.line || "elbowed").toLowerCase()] || "ELBOWED";
+    n.connectorEndStrokeCap = CAPS[String(s.endArrow === undefined ? "arrow" : s.endArrow).toLowerCase()] || "ARROW_LINES";
+    n.connectorStartStrokeCap = CAPS[String(s.startArrow === undefined ? "none" : s.startArrow).toLowerCase()] || "NONE";
+    if (s.color || s.stroke)
+      n.strokes = [solid(s.color || s.stroke)];
+    if (typeof s.strokeWidth === "number")
+      n.strokeWeight = s.strokeWidth;
+    if (s.dashed)
+      n.dashPattern = [8, 6];
+    if (s.label !== undefined && s.label !== "")
+      await setSublayerText(n.text, s.label);
+    return n;
+  }
+
   // plugin/lib/prototype.ts
   var TRIGGERS = {
     click: "ON_CLICK",
@@ -1109,13 +1937,15 @@
   }
 
   // plugin/lib/build.ts
-  var MAX_NODES2 = 3000;
+  var MAX_NODES3 = 3000;
   var SHADOW_DEFAULT = { x: 0, y: 4, blur: 16, spread: 0, color: "#0000001F" };
   async function build(p, _timeoutMs, requestId) {
     const spec = p.spec;
     if (!spec || typeof spec !== "object")
       throw codeError("`spec` must be a node object or an array of node objects", "BAD_ARGS");
-    const roots = Array.isArray(spec) ? spec : [spec];
+    const roots = Array.isArray(spec) ? spec : Array.isArray(spec.slides) ? spec.slides.map(function(sl) {
+      return Object.assign({ type: "slide" }, sl);
+    }) : [spec];
     const d = p.defaults || {};
     const ctx = {
       warnings: [],
@@ -1126,6 +1956,8 @@
       defaults: { font: d.font || "Inter", color: d.color || "#111111", size: d.size || 14 },
       binds: [],
       reactions: [],
+      connectors: [],
+      keys: {},
       requestId,
       total: countNodes(roots),
       lastProgress: 0
@@ -1138,7 +1970,7 @@
       const node = await createNode(roots[i], parent, ctx, "spec" + (roots.length > 1 ? "[" + i + "]" : ""));
       if (!node)
         continue;
-      if (!isAutoLayout(parent) && roots[i].x === undefined && roots[i].y === undefined) {
+      if (node.type !== "SLIDE" && !isAutoLayout(parent) && roots[i].x === undefined && roots[i].y === undefined) {
         if (cursorX === null) {
           place(node, p.x, p.y);
         } else {
@@ -1151,6 +1983,7 @@
     }
     if (ctx.reactions.length)
       await applyBuildReactions(ctx.reactions, ctx.ids, ctx.warnings);
+    const connectors = await createConnectors(ctx);
     for (let i = 0;i < ctx.binds.length; i++)
       ctx.warnings.push(ctx.binds[i].path + ": bind needs a component or componentSet ancestor, ignored");
     if (p.select !== false && made.length && parent.type === "PAGE" && parent === figma.currentPage) {
@@ -1162,7 +1995,7 @@
       rootIds: made.map(function(n) {
         return n.id;
       }),
-      created: ctx.count,
+      created: ctx.count + connectors,
       ids: ctx.ids
     };
     if (ctx.warnings.length)
@@ -1243,7 +2076,7 @@
   function nodeType(s) {
     if (s.type) {
       const t = String(s.type).toLowerCase().replace(/[_\s-]/g, "");
-      return t === "rectangle" ? "rect" : t === "circle" ? "ellipse" : t === "variants" ? "componentset" : t;
+      return t === "rectangle" ? "rect" : t === "circle" ? "ellipse" : t === "variants" ? "componentset" : t === "shapewithtext" ? "shape" : t === "code" ? "codeblock" : t;
     }
     if (Array.isArray(s.variants))
       return "componentset";
@@ -1264,12 +2097,34 @@
       ctx.warnings.push(path + ": not an object, skipped");
       return null;
     }
-    if (ctx.count >= MAX_NODES2)
-      throw codeError("Spec is too large (max " + MAX_NODES2 + " nodes). Split it into several build calls.", "TOO_LARGE");
+    if (ctx.count >= MAX_NODES3)
+      throw codeError("Spec is too large (max " + MAX_NODES3 + " nodes). Split it into several build calls.", "TOO_LARGE");
     checkCancelled(ctx.requestId);
     const type = nodeType(s);
+    requireEditor(type, path);
     let node;
     switch (type) {
+      case "connector":
+        ctx.connectors.push({ spec: s, parent, path });
+        return null;
+      case "sticky":
+        node = await createSticky(s);
+        break;
+      case "shape":
+        node = await createShape(s, path, ctx.warnings);
+        break;
+      case "table":
+        node = await createTable(s, path);
+        break;
+      case "codeblock":
+        node = createCodeBlock(s);
+        break;
+      case "section":
+        node = figma.createSection();
+        break;
+      case "slide":
+        node = createSlide();
+        break;
       case "frame":
       case "component":
         node = type === "component" ? figma.createComponent() : figma.createFrame();
@@ -1306,8 +2161,11 @@
     }
     ctx.count++;
     progress(ctx);
-    parent.appendChild(node);
+    if (type !== "slide" || parent.type !== "PAGE")
+      parent.appendChild(node);
     const parentAuto = isAutoLayout(parent);
+    if (s.key !== undefined)
+      ctx.keys[String(s.key)] = node.id;
     if (s.bind)
       ctx.binds.push({ node, bind: s.bind, path });
     const bindStart = ctx.binds.length;
@@ -1317,6 +2175,10 @@
       node.name = "icon/" + s.icon;
     if (type === "frame" || type === "component")
       await setupFrame(node, s, ctx, path);
+    else if (type === "slide")
+      await setupFrame(node, s, ctx, path, true);
+    else if (type === "section")
+      await setupSection(node, s, ctx, path);
     else if (type === "componentset")
       await setupLayout(node, Object.assign({ layout: "row", wrap: true, gap: 16, padding: 16 }, s), ctx, path);
     else if (type === "text")
@@ -1326,7 +2188,7 @@
     else if (type === "line") {
       node.resize(num(s.w, s.width, 100), 0);
       if (s.stroke === undefined)
-        node.strokes = [solid(ctx.defaults.color)];
+        node.strokes = [solid2(ctx.defaults.color)];
     } else if ((type === "rect" || type === "ellipse") && s.w === undefined && s.width === undefined && s.size === undefined) {
       node.resize(100, 100);
     }
@@ -1334,14 +2196,18 @@
       await overrideTexts(node, s.text, ctx);
     if (type === "componentset" && s.stroke === undefined) {
       const set = node;
-      set.strokes = [solid("#9747FF")];
+      set.strokes = [solid2("#9747FF")];
       set.dashPattern = [10, 5];
       set.cornerRadius = 5;
     }
-    await applyVisuals(node, s, ctx, type);
+    if (FIXED_LOOK.indexOf(type) === -1)
+      await applyVisuals(node, s, ctx, type);
+    else if (typeof s.opacity === "number")
+      node.opacity = s.opacity;
     if (type === "text" && Array.isArray(s.spans))
       await applySpans(node, s, ctx, path);
-    applySize(node, s, parentAuto, type, ctx, path);
+    if (FIXED_LOOK.indexOf(type) === -1 && type !== "section" && type !== "slide")
+      applySize(node, s, parentAuto, type, ctx, path);
     if (type === "component" && !s.variantOf)
       await addProperties(node, s.properties, ctx.binds.splice(bindStart), ctx, path);
     if (parent.layoutMode === "GRID")
@@ -1356,7 +2222,7 @@
     }
     if (s.grow && parentAuto)
       node.layoutGrow = 1;
-    if (typeof s.rotation === "number")
+    if (typeof s.rotation === "number" && "rotation" in node)
       node.rotation = s.rotation;
     if (s.visible === false)
       node.visible = false;
@@ -1375,20 +2241,83 @@
     }
     return node;
   }
-  async function setupFrame(f, s, ctx, path) {
-    f.fills = [];
+  var FIXED_LOOK = ["sticky", "shape", "table", "codeblock"];
+  async function setupFrame(f, s, ctx, path, keepFills) {
+    if (!keepFills)
+      f.fills = [];
     await setupLayout(f, s, ctx, path);
     const children = Array.isArray(s.children) ? s.children : [];
     for (let i = 0;i < children.length; i++) {
       try {
         await createNode(children[i], f, ctx, path + ".children[" + i + "]");
       } catch (e) {
-        if (e.code === "TOO_LARGE" || e.code === "CANCELLED")
+        if (e.code === "TOO_LARGE" || e.code === "CANCELLED" || e.code === "WRONG_EDITOR")
           throw e;
         ctx.warnings.push(path + ".children[" + i + "]: " + (e.message || e));
       }
     }
   }
+  async function setupSection(sec, s, ctx, path) {
+    const children = Array.isArray(s.children) ? s.children : [];
+    const made = [];
+    for (let i = 0;i < children.length; i++) {
+      try {
+        const n = await createNode(children[i], sec, ctx, path + ".children[" + i + "]");
+        if (n)
+          made.push(n);
+      } catch (e) {
+        if (e.code === "TOO_LARGE" || e.code === "CANCELLED" || e.code === "WRONG_EDITOR")
+          throw e;
+        ctx.warnings.push(path + ".children[" + i + "]: " + (e.message || e));
+      }
+    }
+    const w = num(s.w, s.width, 0);
+    const h = num(s.h, s.height, 0);
+    if (w && h) {
+      sec.resizeWithoutConstraints(w, h);
+      return;
+    }
+    const pad = typeof s.padding === "number" ? s.padding : 40;
+    let right = 0;
+    let bottom = 0;
+    for (let i = 0;i < made.length; i++) {
+      right = Math.max(right, made[i].x + made[i].width);
+      bottom = Math.max(bottom, made[i].y + made[i].height);
+    }
+    sec.resizeWithoutConstraints(Math.max(w || right + pad, 100), Math.max(h || bottom + pad, 100));
+  }
+  async function createConnectors(ctx) {
+    let made = 0;
+    for (let i = 0;i < ctx.connectors.length; i++) {
+      const c = ctx.connectors[i];
+      const ends = [];
+      const sides = ["from", "to"];
+      for (let k = 0;k < 2; k++) {
+        const ref = c.spec[sides[k]];
+        let id = ref === undefined ? "" : ctx.keys[String(ref)] || ctx.ids[String(ref)] || "";
+        if (!id && ref !== undefined && /^[\dI;:]+$/.test(String(ref))) {
+          const n = await figma.getNodeByIdAsync(String(ref));
+          if (n)
+            id = n.id;
+        }
+        ends.push(id);
+      }
+      if (!ends[0] || !ends[1]) {
+        ctx.warnings.push(c.path + ': connector ends not found (from "' + c.spec.from + '", to "' + c.spec.to + '")');
+        continue;
+      }
+      try {
+        const n = await createConnector(c.spec, ends[0], ends[1]);
+        c.parent.appendChild(n);
+        if (c.spec.name)
+          n.name = String(c.spec.name);
+        made++;
+      } catch (e) {
+        ctx.warnings.push(c.path + ": " + (e.message || e));
+      }
+    }
+    return made;
+  }
   async function setupLayout(f, s, ctx, path) {
     const layout = String(s.layout || s.direction || "").toLowerCase();
     let mode = layout === "row" || layout === "horizontal" ? "HORIZONTAL" : layout === "column" || layout === "col" || layout === "vertical" ? "VERTICAL" : layout === "grid" ? "GRID" : "NONE";
@@ -1422,7 +2351,7 @@
         if (s.rowGap !== undefined)
           await setNumber(f, "counterAxisSpacing", s.rowGap);
       }
-    } else if (s.w === undefined && s.width === undefined && s.size === undefined) {
+    } else if (s.w === undefined && s.width === undefined && s.size === undefined && f.type !== "SLIDE") {
       f.resize(100, 100);
     }
   }
@@ -1562,7 +2491,7 @@
       t.maxLines = s.maxLines;
     }
     if (s.fill === undefined && s.color === undefined && !s.textStyle)
-      t.fills = [solid(ctx.defaults.color)];
+      t.fills = [solid2(ctx.defaults.color)];
     if (s.textStyle) {
       const style = await findStyle("text", stripPrefix(s.textStyle));
       await loadFont(style.fontName);
@@ -1586,7 +2515,7 @@
         if (typeof color === "string" && color.indexOf("style:") === 0) {
           await t.setRangeFillStyleIdAsync(at, end, (await findStyle("paint", stripPrefix(color))).id);
         } else if (color !== undefined) {
-          t.setRangeFills(at, end, [await toPaint(color)]);
+          t.setRangeFills(at, end, [await toPaint(color, ctx.images)]);
         }
         const deco = { underline: "UNDERLINE", strike: "STRIKETHROUGH", strikethrough: "STRIKETHROUGH", none: "NONE" };
         if (sp.link) {
@@ -1596,7 +2525,7 @@
         }
         if (sp.decoration && deco[sp.decoration])
           t.setRangeTextDecoration(at, end, deco[sp.decoration]);
-        const cases = { upper: "UPPER", lower: "LOWER", title: "TITLE" };
+        const cases = { upper: "UPPER", lower: "LOWER", title: "TITLE", none: "ORIGINAL" };
         if (sp.case && cases[sp.case])
           t.setRangeTextCase(at, end, cases[sp.case]);
       } catch (e) {
@@ -1782,10 +2711,20 @@
   async function applyVisuals(node, s, ctx, type) {
     const fill = s.fill !== undefined ? s.fill : type === "text" ? s.color : undefined;
     if (fill !== undefined && "fills" in node && type !== "image")
-      await setPaints(node, "fills", fill);
+      await setPaints(node, "fills", fill, ctx.images);
     if (s.stroke !== undefined && "strokes" in node) {
-      await setPaints(node, "strokes", s.stroke);
-      node.strokeWeight = typeof s.strokeWidth === "number" ? s.strokeWidth : 1;
+      await setPaints(node, "strokes", s.stroke, ctx.images);
+      if (Array.isArray(s.strokeWidth) && "strokeTopWeight" in node) {
+        const w = s.strokeWidth.map(Number);
+        node.strokeTopWeight = w[0] || 0;
+        node.strokeRightWeight = w[1] === undefined ? w[0] || 0 : w[1] || 0;
+        node.strokeBottomWeight = w[2] === undefined ? w[0] || 0 : w[2] || 0;
+        node.strokeLeftWeight = w[3] === undefined ? w[1] === undefined ? w[0] || 0 : w[1] || 0 : w[3] || 0;
+      } else {
+        node.strokeWeight = typeof s.strokeWidth === "number" ? s.strokeWidth : 1;
+      }
+      if (Array.isArray(s.strokeDash) && "dashPattern" in node)
+        node.dashPattern = s.strokeDash.map(Number);
       if ("strokeAlign" in node && type !== "line" && type !== "text") {
         node.strokeAlign = String(s.strokeAlign || "inside").toUpperCase();
       }
@@ -1839,11 +2778,11 @@
   function stripPrefix(v) {
     return String(v).replace(/^(style|var):/, "");
   }
-  function solid(hex) {
+  function solid2(hex) {
     const c = parseHex(hex);
     return { type: "SOLID", color: { r: c.r, g: c.g, b: c.b }, opacity: c.a };
   }
-  async function setPaints(node, field, value) {
+  async function setPaints(node, field, value, images) {
     if (typeof value === "string" && value.indexOf("style:") === 0) {
       const style = await findStyle("paint", stripPrefix(value));
       if (field === "fills")
@@ -1855,16 +2794,17 @@
     const list = value === null || value === "none" ? [] : Array.isArray(value) ? value : [value];
     const paints = [];
     for (let i = 0;i < list.length; i++)
-      paints.push(await toPaint(list[i]));
+      paints.push(await toPaint(list[i], images));
     node[field] = paints;
   }
-  async function toPaint(v) {
+  var FITS = { fill: "FILL", cover: "FILL", fit: "FIT", contain: "FIT", crop: "CROP", tile: "TILE" };
+  async function toPaint(v, images) {
     if (typeof v === "string") {
       if (v.indexOf("var:") === 0) {
         const variable = await findVariable(stripPrefix(v));
-        return figma.variables.setBoundVariableForPaint(solid("#000000"), "color", variable);
+        return figma.variables.setBoundVariableForPaint(solid2("#000000"), "color", variable);
       }
-      return solid(v);
+      return solid2(v);
     }
     if (v && Array.isArray(v.gradient)) {
       const stops = v.gradient.map(function(c, i, all) {
@@ -1886,6 +2826,15 @@
       ];
       return { type: radial ? "GRADIENT_RADIAL" : "GRADIENT_LINEAR", gradientTransform: transform, gradientStops: stops };
     }
+    if (v && v.imageKey !== undefined) {
+      const bytes = images && images[v.imageKey];
+      if (!bytes)
+        throw codeError("Image fill data missing (use {image: src} with the build tool)", "BAD_ARGS");
+      const paint = { type: "IMAGE", imageHash: figma.createImage(bytes).hash, scaleMode: FITS[String(v.fit || "fill").toLowerCase()] || "FILL" };
+      if (typeof v.opacity === "number")
+        return Object.assign({}, paint, { opacity: v.opacity });
+      return paint;
+    }
     if (v && typeof v.type === "string")
       return v;
     throw codeError("Invalid paint: " + JSON.stringify(v), "BAD_ARGS");
@@ -2313,7 +3262,7 @@
   }
 
   // plugin/lib/export.ts
-  var MAX_NODES3 = 1500;
+  var MAX_NODES4 = 1500;
   var MAX_ASSET_BYTES = 40 << 20;
   var VECTOR_TYPES = ["VECTOR", "BOOLEAN_OPERATION", "STAR", "POLYGON", "ELLIPSE", "LINE"];
   var VISUAL_CSS = [
@@ -2423,6 +3372,11 @@
     }
     if (n.rotation && Math.abs(n.rotation) > 0.01 && n.type !== "TEXT")
       out.rotation = round(n.rotation);
+    if (n.type === "INSTANCE") {
+      const info = await instanceInfo(n);
+      if (info)
+        out.component = info;
+    }
     let css = {};
     try {
       css = await n.getCSSAsync();
@@ -2487,7 +3441,7 @@
         const c = n.children[i];
         if (!c.visible)
           continue;
-        if (ctx.count >= MAX_NODES3) {
+        if (ctx.count >= MAX_NODES4) {
           ctx.truncated = true;
           break;
         }
@@ -2530,6 +3484,33 @@
       })
     };
   }
+  async function instanceInfo(n) {
+    let main = null;
+    try {
+      main = await n.getMainComponentAsync();
+    } catch (e) {}
+    if (!main)
+      return null;
+    const set = main.parent && main.parent.type === "COMPONENT_SET" ? main.parent.name : null;
+    const props = {};
+    const defs = n.componentProperties;
+    const keys = Object.keys(defs);
+    for (let i = 0;i < keys.length; i++) {
+      const d = defs[keys[i]];
+      if (d.type === "INSTANCE_SWAP")
+        continue;
+      props[keys[i].split("#")[0]] = d.value;
+    }
+    const info = { name: set || main.name, props };
+    if (set)
+      info.variant = main.name;
+    const text = n.findOne(function(t) {
+      return t.type === "TEXT" && t.visible;
+    });
+    if (text && text.characters.trim())
+      info.text = text.characters.trim().slice(0, 200);
+    return info;
+  }
 
   // plugin/lib/design-system.ts
   var ALL = ["colors", "text", "effects", "variables", "components"];
@@ -2650,6 +3631,183 @@
     return v;
   }
 
+  // plugin/lib/tokens-export.ts
+  var TYPES2 = { COLOR: "color", FLOAT: "number", STRING: "string", BOOLEAN: "boolean" };
+  async function exportTokens(p) {
+    const only = Array.isArray(p.collections) && p.collections.length ? p.collections : null;
+    const collections = await figma.variables.getLocalVariableCollectionsAsync();
+    const vars = await figma.variables.getLocalVariablesAsync();
+    const byId = {};
+    for (let i = 0;i < vars.length; i++)
+      byId[vars[i].id] = vars[i];
+    const collName = {};
+    for (let i = 0;i < collections.length; i++)
+      collName[collections[i].id] = collections[i].name;
+    const warnings = [];
+    const aliasOf = async function(id) {
+      let v = byId[id] || null;
+      if (!v) {
+        try {
+          v = await figma.variables.getVariableByIdAsync(id);
+        } catch (e) {}
+        if (v)
+          byId[id] = v;
+      }
+      if (!v)
+        return { alias: { collection: "", name: id, missing: true } };
+      let collection = collName[v.variableCollectionId];
+      if (collection === undefined) {
+        try {
+          const c = await figma.variables.getVariableCollectionByIdAsync(v.variableCollectionId);
+          collection = c ? c.name : "";
+        } catch (e) {
+          collection = "";
+        }
+        collName[v.variableCollectionId] = collection;
+      }
+      const out = { alias: { collection, name: v.name } };
+      if (v.remote)
+        out.alias.remote = true;
+      return out;
+    };
+    const value = async function(raw, type) {
+      if (raw && typeof raw === "object" && raw.type === "VARIABLE_ALIAS")
+        return aliasOf(raw.id);
+      if (type === "COLOR" && raw && typeof raw === "object")
+        return toHex(raw);
+      if (type === "FLOAT")
+        return round(Number(raw));
+      return raw;
+    };
+    const outCollections = [];
+    for (let c = 0;c < collections.length; c++) {
+      const col = collections[c];
+      if (only && only.indexOf(col.name) === -1)
+        continue;
+      const modes = col.modes.slice().sort(function(a, b) {
+        return (a.modeId === col.defaultModeId ? 0 : 1) - (b.modeId === col.defaultModeId ? 0 : 1);
+      });
+      const list = [];
+      for (let i = 0;i < vars.length; i++) {
+        const v = vars[i];
+        if (v.variableCollectionId !== col.id)
+          continue;
+        const values = {};
+        for (let m = 0;m < modes.length; m++)
+          values[modes[m].name] = await value(v.valuesByMode[modes[m].modeId], v.resolvedType);
+        const item = { name: v.name, type: TYPES2[v.resolvedType] || "string", values };
+        if (v.description)
+          item.description = v.description;
+        if (v.scopes && v.scopes.length && !(v.scopes.length === 1 && v.scopes[0] === "ALL_SCOPES"))
+          item.scopes = v.scopes.slice();
+        if (v.hiddenFromPublishing)
+          item.hidden = true;
+        list.push(item);
+      }
+      outCollections.push({
+        name: col.name,
+        modes: modes.map(function(m) {
+          return m.name;
+        }),
+        variables: list
+      });
+    }
+    const styles = await localStyles();
+    const paint = [];
+    for (let i = 0;i < styles.paint.length; i++) {
+      const s = styles.paint[i];
+      const paints = [];
+      for (let k = 0;k < s.paints.length; k++) {
+        const pt = s.paints[k];
+        if (pt.visible === false)
+          continue;
+        if (pt.type === "SOLID") {
+          const bound = pt.boundVariables && pt.boundVariables.color;
+          paints.push(bound ? await aliasOf(bound.id) : toHex(pt.color, pt.opacity));
+        } else if (pt.type.indexOf("GRADIENT") === 0) {
+          const t = pt.gradientTransform;
+          const g = {
+            gradient: pt.gradientStops.map(function(st) {
+              return { color: toHex(st.color), at: round(st.position) };
+            })
+          };
+          if (pt.type === "GRADIENT_LINEAR")
+            g.angle = round(Math.atan2(t[0][1], t[0][0]) * 180 / Math.PI);
+          else
+            g.type = pt.type.replace("GRADIENT_", "").toLowerCase();
+          paints.push(g);
+        } else {
+          warnings.push('Paint style "' + s.name + '": ' + pt.type.toLowerCase() + " paints are not exported");
+        }
+      }
+      if (!paints.length)
+        continue;
+      const item = { name: s.name, value: paints.length === 1 ? paints[0] : paints };
+      if (s.description)
+        item.description = s.description;
+      paint.push(item);
+    }
+    const text = [];
+    for (let i = 0;i < styles.text.length; i++) {
+      const s = styles.text[i];
+      const item = { name: s.name, font: s.fontName.family, style: s.fontName.style, size: round(s.fontSize) };
+      const lh = s.lineHeight;
+      if (lh.unit === "PIXELS")
+        item.lineHeight = round(lh.value);
+      else if (lh.unit === "PERCENT")
+        item.lineHeight = round(lh.value) + "%";
+      if (s.letterSpacing.value)
+        item.letterSpacing = s.letterSpacing.unit === "PERCENT" ? round(s.letterSpacing.value) + "%" : round(s.letterSpacing.value);
+      if (s.textCase && s.textCase !== "ORIGINAL")
+        item.case = s.textCase === "UPPER" ? "upper" : s.textCase === "LOWER" ? "lower" : "title";
+      if (s.textDecoration && s.textDecoration !== "NONE")
+        item.decoration = s.textDecoration === "UNDERLINE" ? "underline" : "strike";
+      if (s.paragraphSpacing)
+        item.paragraphSpacing = round(s.paragraphSpacing);
+      const bound = s.boundVariables || {};
+      const keys = Object.keys(bound);
+      if (keys.length) {
+        item.variables = {};
+        for (let k = 0;k < keys.length; k++)
+          if (bound[keys[k]] && bound[keys[k]].id)
+            item.variables[keys[k]] = (await aliasOf(bound[keys[k]].id)).alias;
+      }
+      if (s.description)
+        item.description = s.description;
+      text.push(item);
+    }
+    const effect = [];
+    for (let i = 0;i < styles.effect.length; i++) {
+      const s = styles.effect[i];
+      const list = [];
+      for (let k = 0;k < s.effects.length; k++) {
+        const e = s.effects[k];
+        if (e.visible === false)
+          continue;
+        if (e.type === "DROP_SHADOW" || e.type === "INNER_SHADOW") {
+          const sh = { x: round(e.offset.x), y: round(e.offset.y), blur: round(e.radius), spread: round(e.spread || 0), color: toHex(e.color) };
+          if (e.type === "INNER_SHADOW")
+            sh.inner = true;
+          if (e.boundVariables && e.boundVariables.color)
+            sh.colorVariable = (await aliasOf(e.boundVariables.color.id)).alias;
+          list.push(sh);
+        } else {
+          list.push({ type: e.type === "LAYER_BLUR" ? "layer" : "background", blur: round(e.radius) });
+        }
+      }
+      if (!list.length)
+        continue;
+      const item = { name: s.name, value: list };
+      if (s.description)
+        item.description = s.description;
+      effect.push(item);
+    }
+    const out = { fileName: figma.root.name, collections: outCollections, styles: { colors: paint, text, effects: effect } };
+    if (warnings.length)
+      out.warnings = warnings.slice(0, 40);
+    return out;
+  }
+
   // plugin/lib/find.ts
   var MAX_LIMIT = 500;
   function matcher(q) {
@@ -2762,6 +3920,243 @@
     return out;
   }
 
+  // plugin/lib/roblox.ts
+  var MAX_NODES5 = 2000;
+  var VECTORS = ["VECTOR", "BOOLEAN_OPERATION", "STAR", "POLYGON", "LINE"];
+  async function robloxTree(p) {
+    const node = p.nodeId ? await getNode(p.nodeId) : figma.currentPage.selection[0];
+    if (!node)
+      throw codeError("No nodeId given and nothing is selected", "BAD_ARGS");
+    if (node.type === "PAGE" || node.type === "DOCUMENT")
+      throw codeError("Export a frame, not a page", "BAD_ARGS");
+    const ctx = { count: 0, truncated: false, images: {}, imageBytes: 0 };
+    const tree = await walk2(node, null, ctx);
+    return { tree, images: ctx.images, nodes: ctx.count, truncated: ctx.truncated, fileName: figma.root.name };
+  }
+  function paints(list) {
+    if (!list || list === figma.mixed)
+      return [];
+    const out = [];
+    for (let i = 0;i < list.length; i++) {
+      const pt = list[i];
+      if (pt.visible === false)
+        continue;
+      const o = { type: pt.type, opacity: pt.opacity === undefined ? 1 : round(pt.opacity) };
+      if (pt.type === "SOLID")
+        o.color = toHex(pt.color);
+      else if (pt.type.indexOf("GRADIENT") === 0) {
+        const t = pt.gradientTransform;
+        o.angle = round(Math.atan2(t[0][1], t[0][0]) * 180 / Math.PI);
+        o.stops = pt.gradientStops.map(function(s) {
+          return { color: toHex({ r: s.color.r, g: s.color.g, b: s.color.b }), alpha: round(s.color.a), at: round(s.position) };
+        });
+      } else if (pt.type === "IMAGE") {
+        o.imageHash = pt.imageHash;
+        o.scaleMode = pt.scaleMode;
+      }
+      out.push(o);
+    }
+    return out;
+  }
+  function vectorOnly2(n) {
+    if (VECTORS.indexOf(n.type) !== -1)
+      return true;
+    if (n.type === "TEXT" || !("children" in n) || !n.children.length)
+      return false;
+    for (let i = 0;i < n.children.length; i++)
+      if (n.children[i].visible && !vectorOnly2(n.children[i]))
+        return false;
+    return true;
+  }
+  async function walk2(n, parent, ctx) {
+    ctx.count++;
+    const box = n.absoluteBoundingBox || { x: 0, y: 0, width: n.width || 0, height: n.height || 0 };
+    const pbox = parent && parent.absoluteBoundingBox;
+    const out = {
+      id: n.id,
+      name: n.name,
+      type: n.type,
+      x: pbox ? round(box.x - pbox.x) : 0,
+      y: pbox ? round(box.y - pbox.y) : 0,
+      w: round(box.width),
+      h: round(box.height)
+    };
+    if (n.visible === false)
+      out.hidden = true;
+    if (typeof n.opacity === "number" && n.opacity < 1)
+      out.opacity = round(n.opacity);
+    if (n.rotation && Math.abs(n.rotation) > 0.01)
+      out.rotation = round(-n.rotation);
+    if (n.clipsContent)
+      out.clip = true;
+    if (n.constraints)
+      out.constraints = { h: n.constraints.horizontal, v: n.constraints.vertical };
+    if (n.layoutPositioning === "ABSOLUTE")
+      out.absolute = true;
+    if (n.layoutGrow === 1)
+      out.grow = true;
+    if (n.layoutAlign === "STRETCH")
+      out.stretch = true;
+    if ("layoutSizingHorizontal" in n)
+      out.sizing = { h: n.layoutSizingHorizontal, v: n.layoutSizingVertical };
+    const rb = n.absoluteRenderBounds;
+    if (rb && (Math.abs(rb.x - box.x) > 0.5 || Math.abs(rb.y - box.y) > 0.5 || Math.abs(rb.width - box.width) > 0.5 || Math.abs(rb.height - box.height) > 0.5)) {
+      out.render = { x: round(rb.x - box.x), y: round(rb.y - box.y), w: round(rb.width), h: round(rb.height) };
+    }
+    if ("fills" in n)
+      out.fills = paints(n.fills);
+    if ("strokes" in n && n.strokes.length) {
+      out.strokes = paints(n.strokes);
+      out.strokeWeight = n.strokeWeight === figma.mixed ? round(n.strokeTopWeight || 1) : round(n.strokeWeight);
+      out.strokeAlign = n.strokeAlign;
+      if (n.dashPattern && n.dashPattern.length)
+        out.dashed = true;
+    }
+    if ("topLeftRadius" in n) {
+      const r = [n.topLeftRadius, n.topRightRadius, n.bottomRightRadius, n.bottomLeftRadius].map(round);
+      if (r[0] || r[1] || r[2] || r[3])
+        out.radius = r;
+    } else if (typeof n.cornerRadius === "number" && n.cornerRadius)
+      out.radius = [round(n.cornerRadius), round(n.cornerRadius), round(n.cornerRadius), round(n.cornerRadius)];
+    if ("effects" in n && n.effects.length) {
+      out.effects = n.effects.filter(function(e) {
+        return e.visible !== false;
+      }).map(function(e) {
+        return e.type === "DROP_SHADOW" || e.type === "INNER_SHADOW" ? { type: e.type, x: round(e.offset.x), y: round(e.offset.y), blur: round(e.radius), spread: round(e.spread || 0), color: toHex({ r: e.color.r, g: e.color.g, b: e.color.b }), alpha: round(e.color.a) } : { type: e.type, blur: round(e.radius) };
+      });
+    }
+    if (n.reactions && n.reactions.length) {
+      out.clickable = n.reactions.some(function(r) {
+        return r.trigger && (r.trigger.type === "ON_CLICK" || r.trigger.type === "ON_PRESS");
+      });
+    }
+    if (n.type !== "TEXT" && vectorOnly2(n))
+      out.vector = true;
+    const fills = out.fills || [];
+    for (let i = 0;i < fills.length; i++) {
+      const h = fills[i].imageHash;
+      if (!h || ctx.images[h] !== undefined)
+        continue;
+      const image = figma.getImageByHash(h);
+      if (!image)
+        continue;
+      const bytes = await image.getBytesAsync();
+      if (ctx.imageBytes + bytes.length > 40 << 20)
+        continue;
+      ctx.imageBytes += bytes.length;
+      ctx.images[h] = figma.base64Encode(bytes);
+    }
+    if (n.type === "TEXT") {
+      out.text = textOf2(n);
+      return out;
+    }
+    if (n.layoutMode && n.layoutMode !== "NONE") {
+      const l = {
+        mode: n.layoutMode,
+        padding: [n.paddingTop, n.paddingRight, n.paddingBottom, n.paddingLeft].map(round),
+        gap: round(n.itemSpacing || 0),
+        primary: n.primaryAxisAlignItems,
+        counter: n.counterAxisAlignItems
+      };
+      if (n.layoutWrap === "WRAP") {
+        l.wrap = true;
+        l.counterGap = round(n.counterAxisSpacing || 0);
+      }
+      if (n.layoutMode === "GRID") {
+        l.columns = n.gridColumnCount;
+        l.rows = n.gridRowCount;
+        l.columnGap = round(n.gridColumnGap || 0);
+        l.rowGap = round(n.gridRowGap || 0);
+      }
+      out.layout = l;
+    }
+    if ("children" in n && n.children.length && !out.vector) {
+      out.children = [];
+      for (let i = 0;i < n.children.length; i++) {
+        if (ctx.count >= MAX_NODES5) {
+          ctx.truncated = true;
+          break;
+        }
+        out.children.push(await walk2(n.children[i], n, ctx));
+      }
+    }
+    return out;
+  }
+  function textOf2(t) {
+    const segs = t.getStyledTextSegments(["fontName", "fontSize", "fontWeight", "fills", "textDecoration", "textCase", "letterSpacing", "lineHeight"]);
+    return {
+      characters: t.characters,
+      align: t.textAlignHorizontal,
+      valign: t.textAlignVertical,
+      autoResize: t.textAutoResize,
+      maxLines: t.textTruncation === "ENDING" ? t.maxLines || 1 : 0,
+      segments: segs.map(function(s) {
+        const fill = s.fills.filter(function(f) {
+          return f.visible !== false;
+        })[0];
+        const seg = { text: s.characters, family: s.fontName.family, style: s.fontName.style, weight: s.fontWeight, size: round(s.fontSize) };
+        if (fill && fill.type === "SOLID") {
+          seg.color = toHex(fill.color);
+          if (fill.opacity !== undefined && fill.opacity < 1)
+            seg.alpha = round(fill.opacity);
+        }
+        if (s.textDecoration !== "NONE")
+          seg.decoration = s.textDecoration;
+        if (s.textCase && s.textCase !== "ORIGINAL")
+          seg.textCase = s.textCase;
+        if (s.letterSpacing && s.letterSpacing.value)
+          seg.letterSpacing = round(s.letterSpacing.unit === "PERCENT" ? s.letterSpacing.value / 100 * s.fontSize : s.letterSpacing.value);
+        if (s.lineHeight && s.lineHeight.unit !== "AUTO")
+          seg.lineHeight = round(s.lineHeight.unit === "PERCENT" ? s.lineHeight.value / 100 * s.fontSize : s.lineHeight.value);
+        return seg;
+      })
+    };
+  }
+  async function robloxImages(p) {
+    const items = Array.isArray(p.items) ? p.items : [];
+    const out = [];
+    for (let i = 0;i < items.length; i++) {
+      const it = items[i];
+      const scale = Math.max(1, Math.min(4, Number(it.scale) || 2));
+      let temp = null;
+      try {
+        let node = await getNode(it.id);
+        if (it.mode === "panel" || it.mode === "shadow") {
+          temp = node.clone();
+          if ("children" in temp)
+            for (let k = temp.children.length - 1;k >= 0; k--)
+              temp.children[k].remove();
+          if (it.mode === "panel")
+            temp.effects = [];
+          else {
+            temp.effects = node.effects.filter(function(e) {
+              return e.type === "DROP_SHADOW" && e.visible !== false;
+            });
+            temp.strokes = [];
+          }
+          node = temp;
+        }
+        const bytes = await node.exportAsync({ format: "PNG", constraint: { type: "SCALE", value: scale } });
+        const rb = node.absoluteRenderBounds || node.absoluteBoundingBox;
+        const bb = node.absoluteBoundingBox;
+        out.push({
+          id: it.id,
+          mode: it.mode || "full",
+          scale,
+          b64: figma.base64Encode(bytes),
+          offset: rb && bb ? { x: round(rb.x - bb.x), y: round(rb.y - bb.y) } : { x: 0, y: 0 },
+          size: rb ? { w: round(rb.width), h: round(rb.height) } : { w: round(node.width), h: round(node.height) }
+        });
+      } catch (e) {
+        out.push({ id: it.id, mode: it.mode || "full", error: String(e.message || e) });
+      } finally {
+        if (temp)
+          temp.remove();
+      }
+    }
+    return { images: out };
+  }
+
   // plugin/lib/selection.ts
   var MAX_WAIT_MS = 120000;
   var waiters = {};
@@ -2831,7 +4226,7 @@
     finish(id, codeError("The user cancelled the selection request", "CANCELLED"));
   }
   // package.json
-  var version = "1.5.0";
+  var version = "1.12.0";
 
   // plugin/code.ts
   var DEFAULT_SIZE = { width: 340, height: 540 };
@@ -2853,7 +4248,11 @@
     figma.ui.postMessage(msg);
   }
   function sessionInfo() {
-    return { id: sessionId, fileName: figma.root.name, page: figma.currentPage.name };
+    let fileKey;
+    try {
+      fileKey = figma.fileKey;
+    } catch (e) {}
+    return { id: sessionId, fileName: figma.root.name, page: figma.currentPage.name, pageId: figma.currentPage.id, editorType: figma.editorType, fileKey };
   }
   function clampSize(w, h) {
     return {
@@ -2942,6 +4341,7 @@
     find: find2,
     get_design_system: getDesignSystem,
     design_tokens: designTokens,
+    export_tokens: exportTokens,
     audit,
     get_css: getCss,
     checkpoint,
@@ -2954,14 +4354,25 @@
     prototype,
     annotate,
     export_tree: exportTree,
+    node_info: nodeInfo,
+    roblox_tree: robloxTree,
+    roblox_images: robloxImages,
     ping: function() {
       return Promise.resolve({ pong: true, session: sessionInfo() });
     }
   };
+  var EDITORS2 = {
+    prototype: ["figma"],
+    annotate: ["figma", "dev"],
+    design_tokens: ["figma", "slides"],
+    export_tokens: ["figma", "slides", "dev"]
+  };
+  var EDITOR_NAMES2 = { figma: "Figma Design", figjam: "FigJam", slides: "Figma Slides", dev: "Dev Mode" };
   var READ_ONLY = {
     describe: true,
     find: true,
     get_design_system: true,
+    export_tokens: true,
     audit: true,
     get_css: true,
     screenshot: true,
@@ -2969,11 +4380,13 @@
     list_fonts: true,
     wait_for_selection: true,
     export_tree: true,
+    node_info: true,
+    roblox_tree: true,
     ping: true
   };
   async function handleRequest(msg) {
     const started = Date.now();
-    const mutates = !READ_ONLY[msg.method];
+    const mutates = !READ_ONLY[msg.method] || !!(msg.params && (msg.params.fix === true || msg.params.fixes && msg.params.fixes.length));
     let reply;
     if (mutates)
       commitUndo();
@@ -2981,6 +4394,14 @@
       const handler = HANDLERS[msg.method];
       if (!handler)
         throw codeError("Unknown method: " + msg.method + " (reopen the plugin after updating it)", "UNKNOWN_METHOD");
+      const editors = EDITORS2[msg.method];
+      if (editors && editors.indexOf(figma.editorType) === -1) {
+        throw codeError(msg.method + " is not available in " + (EDITOR_NAMES2[figma.editorType] || figma.editorType) + " (works in " + editors.map(function(e) {
+          return EDITOR_NAMES2[e];
+        }).join(", ") + ").", "WRONG_EDITOR");
+      }
+      if (mutates && figma.editorType === "dev")
+        throw codeError("Dev Mode is read-only: switch the file to Design mode to let the agent edit it.", "WRONG_EDITOR");
       const result = await handler(msg.params || {}, Math.min(Number(msg.timeoutMs) || 30000, 120000), String(msg.id));
       reply = { t: "res", id: msg.id, ok: true, result };
     } catch (e) {
@@ -3282,6 +4703,18 @@
       }
     };
   }
+  async function nodeInfo(p) {
+    const ids = Array.isArray(p.ids) ? p.ids.slice(0, 500) : [];
+    const out = {};
+    for (let i = 0;i < ids.length; i++) {
+      const n = await figma.getNodeByIdAsync(String(ids[i]));
+      if (!n)
+        continue;
+      const pg = pageOf(n);
+      out[ids[i]] = { name: n.name, type: n.type, page: pg ? pg.name : undefined };
+    }
+    return out;
+  }
   var fontCache = null;
   async function listFonts(p) {
     if (!fontCache)