AI-native design editor. Open-source Figma alternative.
fix(tools): create vectors from SVG paths (#440)
rcoenendb15d8d583f8
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 976222769..7bd888aba 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -4,6 +4,7 @@### Fixed+- Let AI and MCP tools create arbitrary vectors from SVG path data without leaving blank layers after invalid input. (#440)- Show stroke colors and weights in AI visual descriptions. (#447)- Stop warning AI agents that supported inline SVG attributes were ignored. (#445)- Help AI agents discover every shape supported by `create_shape`. (#448)diff --git a/packages/core/src/tools/create/vector.ts b/packages/core/src/tools/create/vector.tsindex 143dc45e7..b5614d5ea 100644--- a/packages/core/src/tools/create/vector.ts+++ b/packages/core/src/tools/create/vector.ts@@ -1,40 +1,90 @@import { safeDestr } from 'destr'-import { normalizeVectorNetwork, validateVectorNetwork } from '@open-pencil/scene-graph'+import {+ normalizeVectorNetwork,+ transformVectorNetwork,+ validateVectorNetwork+} from '@open-pencil/scene-graph'import type { VectorNetwork } from '@open-pencil/scene-graph'+import { parseSVGPath } from '@open-pencil/scene-graph/parse-path'import { parseColor } from '#core/color'import { defineTool, nodeSummary } from '#core/tools/schema'+import { computeAccurateBounds } from '#core/vector/curve-math'++interface ParsedVectorPath {+ network: VectorNetwork+ size: { width: number; height: number } | null+}++type VectorPathResult = ParsedVectorPath | { error: string }++function parseSVGVectorPath(path: string): VectorPathResult {+ const network = parseSVGPath(path)+ if (network.segments.length === 0) {+ return { error: 'SVG path data must contain at least one drawable segment' }+ }++ const bounds = computeAccurateBounds(network)+ return {+ network: transformVectorNetwork([1, 0, -bounds.x, 0, 1, -bounds.y, 0, 0, 1], network),+ size: { width: bounds.width, height: bounds.height }+ }+}++function parseVectorNetworkJSON(path: string): VectorPathResult {+ let parsed: unknown+ try {+ parsed = safeDestr(path)+ } catch {+ return { error: 'Invalid VectorNetwork JSON' }+ }++ const errors = validateVectorNetwork(parsed)+ if (errors.length > 0) return { error: `Invalid VectorNetwork: ${errors.join('; ')}` }++ return { network: normalizeVectorNetwork(parsed as VectorNetwork), size: null }+}++function parseVectorPath(path: string): VectorPathResult {+ const trimmed = path.trim()+ if (/^[Mm]/.test(trimmed)) return parseSVGVectorPath(trimmed)+ return parseVectorNetworkJSON(trimmed)+}export const createVector = defineTool({name: 'create_vector',mutates: true,- description: 'Create a vector node with optional path data.',+ description: 'Create a vector node from SVG path data or a VectorNetwork.',params: {x: { type: 'number', description: 'X position', required: true },y: { type: 'number', description: 'Y position', required: true },name: { type: 'string', description: 'Node name' },- path: { type: 'string', description: 'VectorNetwork JSON' },+ path: {+ type: 'string',+ description:+ 'SVG path data (preferred, e.g. "M0 0 L100 0 L50 80 Z") or VectorNetwork JSON, e.g. {"vertices":[{"x":0,"y":0},{"x":10,"y":0}],"segments":[{"start":0,"end":1}],"regions":[]}'+ },fill: { type: 'color', description: 'Fill color (hex)' },stroke: { type: 'color', description: 'Stroke color (hex)' },stroke_weight: { type: 'number', description: 'Stroke weight' },parent_id: { type: 'string', description: 'Parent node ID' }},execute: (figma, args) => {+ let parsedPath: ParsedVectorPath | null = null+ if (args.path !== undefined) {+ const parsed = parseVectorPath(args.path)+ if ('error' in parsed) return parsed+ parsedPath = parsed+ }+const node = figma.createVector()node.x = args.xnode.y = args.yif (args.name) node.name = args.name- if (args.path) {- let parsed: VectorNetwork- try {- parsed = safeDestr<VectorNetwork>(args.path)- } catch {- return { error: 'Invalid JSON in path parameter' }- }- const errors = validateVectorNetwork(parsed)- if (errors.length > 0) return { error: `Invalid VectorNetwork: ${errors.join('; ')}` }- figma.graph.updateNode(node.id, { vectorNetwork: normalizeVectorNetwork(parsed) })+ if (parsedPath) {+ figma.graph.updateNode(node.id, { vectorNetwork: parsedPath.network })+ if (parsedPath.size) node.resize(parsedPath.size.width, parsedPath.size.height)}if (args.fill) {node.fills = [{ type: 'SOLID', color: parseColor(args.fill), opacity: 1, visible: true }]diff --git a/packages/scene-graph/src/parse-path.ts b/packages/scene-graph/src/parse-path.tsindex 60fa27884..87f3fb8f3 100644--- a/packages/scene-graph/src/parse-path.ts+++ b/packages/scene-graph/src/parse-path.ts@@ -76,7 +76,9 @@ export function parseSVGPath(d: string, windingRule: WindingRule = 'NONZERO'): VaddSegment(x1, y1, x2, y2, cp1x, cp1y, cp2x, cp2y)}- const normalized = svgpath(d).abs().unshort().unarc()+ const parsed = svgpath(d)+ if ('err' in parsed && parsed.err) return { vertices, segments, regions: [] }+ const normalized = parsed.abs().unshort().unarc()normalized.iterate((seg) => {const cmd = seg[0]diff --git a/packages/scene-graph/src/vector-network.ts b/packages/scene-graph/src/vector-network.tsindex 96b6f75b4..5924160fc 100644--- a/packages/scene-graph/src/vector-network.ts+++ b/packages/scene-graph/src/vector-network.ts@@ -96,36 +96,116 @@ export function cloneVectorNetwork(vn: VectorNetwork): VectorNetwork {* Validate a VectorNetwork structure, returning an array of error messages.* Empty array means the network is valid.*/-export function validateVectorNetwork(vn: VectorNetwork): string[] {+export function validateVectorNetwork(value: unknown): string[] {+ if (!isRecord(value)) return ['network must be an object']+ if (!Array.isArray(value.vertices)) return ['vertices must be an array']+ if (!Array.isArray(value.segments)) return ['segments must be an array']+const errors: string[] = []- if (!Array.isArray(vn.vertices)) {- errors.push('vertices must be an array')- return errors+ validateVertices(value.vertices, errors)+ validateSegments(value.segments, value.vertices.length, errors)+ if (Array.isArray(value.regions)) {+ validateRegions(value.regions, value.segments.length, errors)+ } else {+ errors.push('regions must be an array')}- if (!Array.isArray(vn.segments)) {- errors.push('segments must be an array')- return errors+ return errors+}++function validateVertices(vertices: unknown[], errors: string[]): void {+ for (let index = 0; index < vertices.length; index++) {+ if (!isFiniteVector(vertices[index])) {+ errors.push(`vertex[${index}]: x and y must be finite numbers`)+ }}- if (!Array.isArray(vn.regions)) errors.push('regions must be an array')- const vertexCount = vn.vertices.length- for (let i = 0; i < vn.vertices.length; i++) {- const v = vn.vertices[i]- if (typeof v.x !== 'number' || typeof v.y !== 'number') {- errors.push(`vertex[${i}]: x and y must be numbers`)+}++function validateSegments(segments: unknown[], vertexCount: number, errors: string[]): void {+ for (let index = 0; index < segments.length; index++) {+ const segment = segments[index]+ if (!isRecord(segment)) {+ errors.push(`segment[${index}] must be an object`)+ continue+ }+ if (!isInteger(segment.start) || !isInteger(segment.end)) {+ errors.push(`segment[${index}]: start and end must be integers`)+ continue}+ if (segment.start < 0 || segment.start >= vertexCount) {+ errors.push(`segment[${index}]: start index ${segment.start} out of range`)+ }+ if (segment.end < 0 || segment.end >= vertexCount) {+ errors.push(`segment[${index}]: end index ${segment.end} out of range`)+ }+ validateSegmentTangents(segment, index, errors)}- for (let i = 0; i < vn.segments.length; i++) {- const s = vn.segments[i]- if (typeof s.start !== 'number' || typeof s.end !== 'number') {- errors.push(`segment[${i}]: start and end must be numbers`)- } else {- if (s.start < 0 || s.start >= vertexCount)- errors.push(`segment[${i}]: start index ${s.start} out of range`)- if (s.end < 0 || s.end >= vertexCount)- errors.push(`segment[${i}]: end index ${s.end} out of range`)+}++function validateSegmentTangents(+ segment: Record<string, unknown>,+ index: number,+ errors: string[]+): void {+ for (const tangentKey of ['tangentStart', 'tangentEnd'] as const) {+ const tangent = segment[tangentKey]+ if (tangent !== undefined && !isFiniteVector(tangent)) {+ errors.push(`segment[${index}]: ${tangentKey} must contain finite x and y numbers`)}}- return errors+}++function validateRegions(regions: unknown[], segmentCount: number, errors: string[]): void {+ for (let regionIndex = 0; regionIndex < regions.length; regionIndex++) {+ const region = regions[regionIndex]+ if (!isRecord(region) || !Array.isArray(region.loops)) {+ errors.push(`region[${regionIndex}]: loops must be an array`)+ continue+ }+ if (region.windingRule !== 'NONZERO' && region.windingRule !== 'EVENODD') {+ errors.push(`region[${regionIndex}]: windingRule must be NONZERO or EVENODD`)+ }+ validateRegionLoops(region.loops, regionIndex, segmentCount, errors)+ }+}++function validateRegionLoops(+ loops: unknown[],+ regionIndex: number,+ segmentCount: number,+ errors: string[]+): void {+ for (let loopIndex = 0; loopIndex < loops.length; loopIndex++) {+ const loop = loops[loopIndex]+ if (!Array.isArray(loop)) {+ errors.push(`region[${regionIndex}].loop[${loopIndex}] must be an array`)+ continue+ }+ for (const segmentIndex of loop) {+ if (!isInteger(segmentIndex) || segmentIndex < 0 || segmentIndex >= segmentCount) {+ errors.push(+ `region[${regionIndex}].loop[${loopIndex}]: segment index ${String(segmentIndex)} out of range`+ )+ }+ }+ }+}++function isFiniteVector(value: unknown): value is Vector {+ return (+ isRecord(value) &&+ typeof value.x === 'number' &&+ Number.isFinite(value.x) &&+ typeof value.y === 'number' &&+ Number.isFinite(value.y)+ )+}++function isInteger(value: unknown): value is number {+ return typeof value === 'number' && Number.isInteger(value)+}++function isRecord(value: unknown): value is Record<string, unknown> {+ return typeof value === 'object' && value !== null}/**diff --git a/tests/engine/io/svg/path-parse.test.ts b/tests/engine/io/svg/path-parse.test.tsindex 0e5a1dae1..6ae296f20 100644--- a/tests/engine/io/svg/path-parse.test.ts+++ b/tests/engine/io/svg/path-parse.test.ts@@ -98,6 +98,10 @@ describe('parseSVGPath', () => {expect(vn.segments.length).toBeGreaterThan(5)})+ test('malformed input does not preserve partial geometry', () => {+ expect(parseSVGPath('M0 0 L')).toEqual({ vertices: [], segments: [], regions: [] })+ })+test('round-trip: parse → export produces valid SVG paths', () => {const d = 'M0 0 L100 0 L100 100 L0 100 Z'const vn = parseSVGPath(d)diff --git a/tests/engine/tools/create.test.ts b/tests/engine/tools/create.test.tsindex e1c80a087..0f115ceca 100644--- a/tests/engine/tools/create.test.ts+++ b/tests/engine/tools/create.test.ts@@ -116,3 +116,91 @@ describe('render', () => {expect(result.textAlignHorizontal).toBe('CENTER')})})++describe('create_vector', () => {+ test('creates tightly bounded curved geometry from SVG path data', () => {+ const { figma, graph } = setupToolTest()+ const result = getTool('create_vector').execute(figma, {+ x: 100,+ y: 200,+ name: 'Curved outline',+ path: 'M10 20 C20 20 30 40 40 40 L10 40 Z'+ }) as ToolResult+ const node = expectDefined(+ graph.getNode(expectDefined(result.id, 'created vector id')),+ 'created vector'+ )+ const network = expectDefined(node.vectorNetwork, 'SVG vector network')++ expect({ x: node.x, y: node.y, width: node.width, height: node.height }).toEqual({+ x: 100,+ y: 200,+ width: 30,+ height: 20+ })+ expect(network.vertices).toEqual([+ { x: 0, y: 0 },+ { x: 30, y: 20 },+ { x: 0, y: 20 }+ ])+ expect(network.segments[0]?.tangentStart).toEqual({ x: 10, y: 0 })+ expect(network.segments[0]?.tangentEnd).toEqual({ x: -10, y: 0 })+ expect(network.regions).toEqual([{ windingRule: 'NONZERO', loops: [[0, 1, 2]] }])+ })++ test('preserves complete VectorNetwork JSON topology', () => {+ const { figma, graph } = setupToolTest()+ const result = getTool('create_vector').execute(figma, {+ x: 0,+ y: 0,+ path: JSON.stringify({+ vertices: [+ { x: 0, y: 0 },+ { x: 10, y: 0 },+ { x: 0, y: 10 }+ ],+ segments: [+ { start: 0, end: 1, tangentStart: { x: 1, y: 0 }, tangentEnd: { x: -1, y: 0 } },+ { start: 1, end: 2 },+ { start: 2, end: 0 }+ ],+ regions: [{ windingRule: 'EVENODD', loops: [[0, 1, 2]] }]+ })+ }) as ToolResult+ const node = expectDefined(+ graph.getNode(expectDefined(result.id, 'created vector id')),+ 'created vector'+ )++ expect(node.vectorNetwork).toEqual({+ vertices: [+ { x: 0, y: 0 },+ { x: 10, y: 0 },+ { x: 0, y: 10 }+ ],+ segments: [+ {+ start: 0,+ end: 1,+ tangentStart: { x: 1, y: 0 },+ tangentEnd: { x: -1, y: 0 }+ },+ { start: 1, end: 2, tangentStart: { x: 0, y: 0 }, tangentEnd: { x: 0, y: 0 } },+ { start: 2, end: 0, tangentStart: { x: 0, y: 0 }, tangentEnd: { x: 0, y: 0 } }+ ],+ regions: [{ windingRule: 'EVENODD', loops: [[0, 1, 2]] }]+ })+ })++ test('rejects invalid supplied paths before creating a node', () => {+ const { figma, graph } = setupToolTest()+ const tool = getTool('create_vector')+ const before = graph.nodes.size++ for (const path of ['', 'not a path', 'null', 'M0 0 L']) {+ const result = tool.execute(figma, { x: 0, y: 0, name: 'Ghost', path }) as ToolResult+ expect(result.error).toBeDefined()+ expect(graph.nodes.size).toBe(before)+ }+ })+})diff --git a/tests/engine/vector/validate.test.ts b/tests/engine/vector/validate.test.tsindex 1de7e9e0f..c443ade57 100644--- a/tests/engine/vector/validate.test.ts+++ b/tests/engine/vector/validate.test.ts@@ -51,6 +51,25 @@ describe('validateVectorNetwork', () => {regions: []} as VectorNetworkconst errors = validateVectorNetwork(network)- expect(errors[0]).toContain('x and y must be numbers')+ expect(errors[0]).toContain('x and y must be finite numbers')+ })++ test('rejects non-object input without throwing', () => {+ expect(validateVectorNetwork(null)).toEqual(['network must be an object'])+ expect(validateVectorNetwork('not a network')).toEqual(['network must be an object'])+ })++ test('rejects invalid region topology', () => {+ const errors = validateVectorNetwork({+ vertices: [+ { x: 0, y: 0 },+ { x: 10, y: 0 }+ ],+ segments: [{ start: 0, end: 1 }],+ regions: [{ windingRule: 'INVALID', loops: [[1]] }]+ })++ expect(errors).toContain('region[0]: windingRule must be NONZERO or EVENODD')+ expect(errors).toContain('region[0].loop[0]: segment index 1 out of range')})})