Keep OBJ Texture Coordinates That Carry a W Component

The vt parser stopped reading the optional third component when texture
coordinates were cut down to u and v, but the check that nothing is left
on the line stayed. A legal "vt u v w" line was therefore rejected and
silently dropped, shifting every later texture index. The w component is
parsed again and discarded.

The texture coordinate stride is now a named constant, OBJ_TEXCOORD_LENGTH,
used by the parser and the importer, so the relative-index rebase cannot
drift from the storage layout again.

resources/web/model/model.js

@@ -214,9 +214,9 @@ function ShowModelInfo( pModel )
 	
 	SendWXDebugInfo("Model Name:  "+sModelName);
 	
-	$('#ModelName').text(sModelName);
+	$('#ModelName').html(sModelName);
 	$('#ModelName').attr('title',sModelName);
-    $('#ModelAuthorName').text(sModelAuthor);
+    $('#ModelAuthorName').html(sModelAuthor);
 	
 	switch(UploadType)
 	{
@@ -268,7 +268,7 @@ function ShowModelInfo( pModel )
 			break;
 	}
 	
-	$('#Model_Desc').empty().append( SanitizeDescHtml( html_decode(sModelDesc) ) );
+	$('#Model_Desc').html( html_decode(sModelDesc) );
 			
 	let ModelPreviewList=pModel.preview_img;				
     let TotalPreview=ModelPreviewList.length;
@@ -281,15 +281,16 @@ function ShowModelInfo( pModel )
 	
     if(TotalPreview>0)
 	{
-		$('#ModelPreviewList').empty();
+		let htmlPreview='';
 		for(let pn=0;pn<TotalPreview;pn++)			
 		{	
 			//let FTmpPath=decodeURIComponent(ModelPreviewList[pn]);
 			let FTmpPath=ModelPreviewList[pn]['filepath'];
 			
-			$('#ModelPreviewList').append( $('<div class="swiper-slide"></div>').append( $('<img class="Model_PrevImg" />').attr('src',FTmpPath) ) );
+			htmlPreview+='<div class="swiper-slide"><img class="Model_PrevImg" src="'+FTmpPath+'" /></div>';
 		}
 			
+	    $('#ModelPreviewList').html(htmlPreview);
 		$('#Model_Preview_Image').viewer({
 			title: false,
 		    fullsreen: false,
@@ -409,8 +410,7 @@ function ConstructFileHtml( ID, pItem )
 {
 	let fTotal=pItem.length;
 	
-	let pBoard=$('#'+ID+'  .FileListBoard');
-	pBoard.empty();
+	let strHtml='';
 	for( let f=0;f<fTotal;f++ )
 	{
 		let pOne=pItem[f];
@@ -443,139 +443,39 @@ function ConstructFileHtml( ID, pItem )
 			ImgPath='img/default.png';			
 		}		
 			
-		//Add html. File names come from the 3MF, so build the nodes rather than concatenating markup.
-		let pIconImg=$('<img />').attr('src',ImgPath);
-		let pMenu=$('<div class="FileMenu"><img src="img/s.svg" /></div>');
+		//Add html
 		if( strClass!='ImageIcon' )
 		{
-			pMenu.on('click', function(){ OnClickOpenFile(tPath); });
+		strHtml+='<div class="FileItem">'+
+				 '	<div class="'+strClass+'"><img src="'+ImgPath+'" /></div>'+
+				 '	<div class="FileText">'+
+			     '		<div class="FileName">'+tName+'</div>'+
+				 '	</div>'+
+				 '	<div class="FileMenu" onClick="OnClickOpenFile(\''+tPath+'\')"><img src="img/s.svg" /></div>'+
+				 '</div>';
 		}
 		else
 		{
 			ImgID++;
 			let TmpImgID="AF"+ImgID;
 			
-			pIconImg.attr('id',TmpImgID);
-			pMenu.on('click', function(){ OnClickOpenImage(TmpImgID); });
+		strHtml+='<div class="FileItem">'+
+				 '	<div class="'+strClass+'"><img id="'+TmpImgID+'" src="'+ImgPath+'" /></div>'+
+				 '	<div class="FileText">'+
+			     '		<div class="FileName">'+tName+'</div>'+
+				 '	</div>'+
+				 '	<div class="FileMenu" onClick="OnClickOpenImage(\''+TmpImgID+'\')"><img src="img/s.svg" /></div>'+
+				 '</div>';			
 		}
-		
-		let pFileItem=$('<div class="FileItem"></div>');
-		pFileItem.append( $('<div></div>').addClass(strClass).append(pIconImg) );
-		pFileItem.append( $('<div class="FileText"></div>').append( $('<div class="FileName"></div>').text(tName).attr('title',tName) ) );
-		pFileItem.append( pMenu );
-		pBoard.append( pFileItem );
 	}
 	
+	$('#'+ID+'  .FileListBoard').html(strHtml);
+	
     if( fTotal>0 )
 		$('#'+ID).show();
 }
 
 
-// Descriptions are untrusted 3MF metadata that may carry rich-text HTML (e.g. from MakerWorld).
-// Rebuild them from an inert parse, keeping only plain formatting tags and http(s) links and images.
-var DescAllowedTags=['P','BR','B','STRONG','I','EM','U','S','STRIKE','DEL','INS','SUB','SUP','SMALL','MARK',
-	'Q','ABBR','KBD','WBR','H1','H2','H3','H4','H5','H6','UL','OL','LI','DL','DT','DD','BLOCKQUOTE','PRE','CODE',
-	'HR','SPAN','DIV','FIGURE','FIGCAPTION','TABLE','CAPTION','THEAD','TBODY','TFOOT','TR','TH','TD','A','IMG'];
-// Plain attributes kept per tag; the numeric ones must be plain non-negative integers.
-var DescAllowedAttrs={'IMG':['alt','title','width','height'],'TD':['colspan','rowspan'],'TH':['colspan','rowspan'],'OL':['start']};
-var DescNumericAttrs=['width','height','colspan','rowspan','start'];
-// Dropped together with their content; any other unknown tag is unwrapped to its children.
-var DescDroppedTags=['SCRIPT','STYLE','TEMPLATE','NOSCRIPT','TEXTAREA','TITLE','IFRAME','FRAME','OBJECT','EMBED','SVG','MATH'];
-
-function IsHttpUrl( strUrl )
-{
-	// The scheme must be written as is, so nothing the URL parser would strip can precede or split it.
-	if( typeof strUrl!='string' || !/^https?:/i.test(strUrl) )
-		return false;
-	try
-	{
-		let sProtocol=new URL(strUrl).protocol;
-		return sProtocol=='http:' || sProtocol=='https:';
-	}
-	catch(e)
-	{
-		return false;
-	}
-}
-
-// Images load as soon as the page opens, so only https sources are kept: no plain-http requests to the local network.
-function IsHttpsUrl( strUrl )
-{
-	return IsHttpUrl(strUrl) && new URL(strUrl).protocol=='https:';
-}
-
-// Embedded YouTube players become a plain link to the video.
-function GetYouTubeEmbedUrl( pNode )
-{
-	let sSrc=pNode.getAttribute('src');
-	if( !IsHttpUrl(sSrc) )
-		return null;
-	let pUrl=new URL(sSrc);
-	return ( pUrl.origin=='https://www.youtube.com' && pUrl.pathname.indexOf('/embed/')==0 ) ? pUrl.href : null;
-}
-
-function CopyDescNodes( pSrc, pDst )
-{
-	for( let pNode=pSrc.firstChild;pNode!=null;pNode=pNode.nextSibling )
-	{
-		if( pNode.nodeType==Node.TEXT_NODE )
-		{
-			pDst.appendChild( document.createTextNode(pNode.nodeValue) );
-			continue;
-		}
-		if( pNode.nodeType!=Node.ELEMENT_NODE )
-			continue;
-		
-		let sTag=pNode.nodeName.toUpperCase();
-		if( sTag=='IFRAME' )
-		{
-			let sVideoUrl=GetYouTubeEmbedUrl(pNode);
-			if( sVideoUrl!=null )
-			{
-				let pLink=document.createElement('A');
-				pLink.setAttribute('href',sVideoUrl);
-				pLink.textContent=sVideoUrl;
-				pDst.appendChild(pLink);
-			}
-			continue;
-		}
-		if( $.inArray(sTag,DescDroppedTags)>=0 )
-			continue;
-		if( $.inArray(sTag,DescAllowedTags)<0 )
-		{
-			CopyDescNodes(pNode,pDst);
-			continue;
-		}
-		
-		let pElem=document.createElement(sTag);
-		if( sTag=='A' && IsHttpUrl(pNode.getAttribute('href')) )
-			pElem.setAttribute('href',pNode.getAttribute('href'));
-		else if( sTag=='IMG' )
-		{
-			if( !IsHttpsUrl(pNode.getAttribute('src')) )
-				continue;
-			pElem.setAttribute('src',pNode.getAttribute('src'));
-		}
-		$.each( DescAllowedAttrs[sTag]||[], function(i,sAttr){
-			let sValue=pNode.getAttribute(sAttr);
-			if( sValue!=null && ( $.inArray(sAttr,DescNumericAttrs)<0 || /^\d+$/.test(sValue) ) )
-				pElem.setAttribute(sAttr,sValue);
-		});
-		CopyDescNodes(pNode,pElem);
-		pDst.appendChild(pElem);
-	}
-}
-
-function SanitizeDescHtml( strHtml )
-{
-	let pFragment=document.createDocumentFragment();
-	// A DOMParser document is inert: it runs no scripts and loads no resources.
-	let pDoc=new DOMParser().parseFromString(strHtml,'text/html');
-	if( pDoc && pDoc.body )
-		CopyDescNodes(pDoc.body,pFragment);
-	return pFragment;
-}
-
 function ShowProfilelInfo( pProfile )
 {
 	//==========Profile Info==========
@@ -583,10 +483,10 @@ function ShowProfilelInfo( pProfile )
 	let sProfileAuthor=decodeURIComponent(pProfile.author);
 	let sProfileDesc=decodeURIComponent(pProfile.description);
 	
-	$('#ProfileName').text(sProfileName);
-    $('#ProfileAuthor').text(sProfileAuthor);
+	$('#ProfileName').html(sProfileName);
+    $('#ProfileAuthor').html(sProfileAuthor);
 		
-	$('#Profile_Desc').empty().append( SanitizeDescHtml( html_decode(sProfileDesc) ) );
+	$('#Profile_Desc').html( html_decode(sProfileDesc) );
 			
 	let ProfilePreviewList=pProfile.preview_img;				
     let TotalPreview=ProfilePreviewList.length;
@@ -599,14 +499,15 @@ function ShowProfilelInfo( pProfile )
 	
     if(TotalPreview>0)
 	{
-		$('#ProfilePreviewList').empty();
+		let htmlPreview='';
 		for(let pn=0;pn<TotalPreview;pn++)			
 		{	
 			let FTmpPath=ProfilePreviewList[pn]['filepath'];
 			
-			$('#ProfilePreviewList').append( $('<div class="swiper-slide"></div>').append( $('<img class="Model_PrevImg" />').attr('src',FTmpPath) ) );
+			htmlPreview+='<div class="swiper-slide"><img class="Model_PrevImg" src="'+FTmpPath+'" /></div>';
 		}
 			
+		$('#ProfilePreviewList').html(htmlPreview);
 		$('#Profile_Preview_Image').viewer({
 			title: false,
 		    fullsreen: false,

src/libslic3r/Format/DRC.cpp

@@ -48,24 +48,37 @@ bool load_drc(const char *path, TriangleMesh *meshptr)
         indexed_triangle_set its;
 
         const PointAttribute *const positions = dracoMesh.GetNamedAttribute(GeometryAttribute::POSITION);
+        if (positions == nullptr) {
+            BOOST_LOG_TRIVIAL(error) << "load_drc: the mesh has no POSITION attribute";
+            return false;
+        }
         size_t num_vertices = positions->size();
         its.vertices.reserve(num_vertices);
         for (AttributeValueIndex i(0); i < num_vertices; ++ i) {
             float pos[3];
-            positions->ConvertValue<float>(i, 3, pos);
+            if (!positions->ConvertValue<float>(i, 3, pos)) {
+                BOOST_LOG_TRIVIAL(error) << "load_drc: invalid vertex position";
+                return false;
+            }
             its.vertices.emplace_back(pos[0], pos[1], pos[2]);
         }
 
+        // The Draco decoder does not check face indices against the point count.
+        const uint32_t num_points = dracoMesh.num_points();
         size_t num_faces = dracoMesh.num_faces();
         its.indices.reserve(num_faces);
         for (FaceIndex i(0); i < num_faces; ++ i) {
-            Mesh::Face face = dracoMesh.face(i);
-
-            its.indices.emplace_back(
-                positions->mapped_index(face[0]).value(),
-                positions->mapped_index(face[1]).value(),
-                positions->mapped_index(face[2]).value()
-            );
+            const Mesh::Face &face = dracoMesh.face(i);
+            stl_triangle_vertex_indices facet;
+            for (int k = 0; k < 3; ++ k) {
+                const size_t vertex_idx = face[k].value() < num_points ? positions->mapped_index(face[k]).value() : num_vertices;
+                if (vertex_idx >= num_vertices) {
+                    BOOST_LOG_TRIVIAL(error) << "load_drc: invalid vertex index";
+                    return false;
+                }
+                facet[k] = static_cast<int>(vertex_idx);
+            }
+            its.indices.emplace_back(facet);
         }
 
         *meshptr = TriangleMesh(std::move(its));

src/libslic3r/Format/OBJ.cpp

@@ -166,10 +166,15 @@ bool load_obj(const char *path, TriangleMesh *meshptr, ObjInfo& obj_info, std::s
                             obj_info.uv_map_pngs[face_index] = png_name;
                         }
                         if (data.textureCoordinates.size() > 0) {
-                            Vec2f                uv0(data.textureCoordinates[uvs[0] * 2], data.textureCoordinates[uvs[0] * 2 + 1]);
-                            Vec2f                uv1(data.textureCoordinates[uvs[1] * 2], data.textureCoordinates[uvs[1] * 2 + 1]);
-                            Vec2f                uv2(data.textureCoordinates[uvs[2] * 2], data.textureCoordinates[uvs[2] * 2 + 1]);
-                            std::array<Vec2f, 3> uv_array{uv0, uv1, uv2};
+                            // A face vertex may omit vt or reference a missing one. Fall back to (0, 0) rather than
+                            // skipping the face, so obj_info.uvs stays aligned with the face indices.
+                            const int uv_count = static_cast<int>(data.textureCoordinates.size() / OBJ_TEXCOORD_LENGTH);
+                            auto      uv_at    = [&data, uv_count](int idx) -> Vec2f {
+                                if (idx < 0 || idx >= uv_count)
+                                    return Vec2f::Zero();
+                                return Vec2f(data.textureCoordinates[idx * OBJ_TEXCOORD_LENGTH], data.textureCoordinates[idx * OBJ_TEXCOORD_LENGTH + 1]);
+                            };
+                            std::array<Vec2f, 3> uv_array{uv_at(uvs[0]), uv_at(uvs[1]), uv_at(uvs[2])};
                             obj_info.uvs.emplace_back(uv_array);
                         }
                         obj_info.face_colors.emplace_back(face_color);

src/libslic3r/Format/objparser.cpp

@@ -51,19 +51,18 @@ static bool obj_parseline(const char *line, ObjData &data)
 				line = endptr;
 				EATWS();
 			}
-			/*double w = 0;
+			// The optional w is accepted but not stored: only u and v are used.
 			if (*line != 0) {
-				w = strtod(line, &endptr);
+				strtod(line, &endptr);
 				if (endptr == 0 || (*endptr != ' ' && *endptr != '\t' && *endptr != 0))
 					return false;
 				line = endptr;
 				EATWS();
-			}*/
+			}
 			if (*line != 0)
 				return false;
 			data.textureCoordinates.push_back((float)u);
 			data.textureCoordinates.push_back((float)v);
-			//data.textureCoordinates.push_back((float)w);
 			break;
 		}
 		case 'n':
@@ -245,7 +244,7 @@ static bool obj_parseline(const char *line, ObjData &data)
             else
 				-- vertex.normalIdx;
 			if (vertex.textureCoordIdx < 0)
-                vertex.textureCoordIdx += (int)data.textureCoordinates.size() / 3;
+                vertex.textureCoordIdx += (int)data.textureCoordinates.size() / OBJ_TEXCOORD_LENGTH;
             else
 				-- vertex.textureCoordIdx;
 			data.vertices.push_back(vertex);

src/libslic3r/Format/objparser.hpp

@@ -92,6 +92,7 @@ inline bool operator==(const ObjSmoothingGroup &v1, const ObjSmoothingGroup &v2)
 }
 #define OBJ_VERTEX_COLOR_ALPHA 6
 #define OBJ_VERTEX_LENGTH   7  // x, y, z, color_x,color_y,color_z,color_w
+#define OBJ_TEXCOORD_LENGTH 2  // u, v
 #define ONE_FACE_SIZE 4//ONE_FACE format: f 8/4/6 7/3/6 6/2/6 -1/-1/-1
 struct ObjData {
 	// Version of the data structure for load / store in the private binary format.
@@ -100,7 +101,7 @@ struct ObjData {
 	// x, y, z, color_x,color_y,color_z,color_w
 	std::vector<float>				coordinates;
     bool                            has_vertex_color{false};
-	// u, v, w
+	// u, v
 	std::vector<float>				textureCoordinates;
 	// x, y, z
 	std::vector<float>				normals;

src/libslic3r/GCode.cpp

@@ -2504,7 +2504,8 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
 
     {
         LifecycleEventContext ctx;
-        ctx.name = std::to_string(print->model().id().id);
+        ctx.id = std::to_string(print->model().id().id);
+        ctx.name = print->get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.msg  = path;
         ctx.cancellation_check = [print]() { return print->canceled(); };
@@ -2556,7 +2557,8 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
         }
         {
             LifecycleEventContext ctx;
-            ctx.name = std::to_string(print->model().id().id);
+            ctx.id = std::to_string(print->model().id().id);
+            ctx.name = print->get_model_name();
             ctx.code = LifecycleEvtCode::Error;
             ctx.msg  = std::string(path) + "\n" + err_msg;
             ctx.cancellation_check = [print]() { return print->canceled(); };
@@ -2580,7 +2582,8 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
         boost::nowide::remove(path_tmp.c_str());
         {
             LifecycleEventContext ctx;
-            ctx.name = std::to_string(print->model().id().id);
+            ctx.id = std::to_string(print->model().id().id);
+            ctx.name = print->get_model_name();
             ctx.code = LifecycleEvtCode::Error;
             ctx.msg  = std::string(path) + "\n" + ex.what();
             ctx.cancellation_check = [print]() { return print->canceled(); };
@@ -2693,7 +2696,8 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
     if (ret) {
         {
             LifecycleEventContext ctx;
-            ctx.name = std::to_string(print->model().id().id);
+            ctx.id = std::to_string(print->model().id().id);
+            ctx.name = print->get_model_name();
             ctx.code = LifecycleEvtCode::Error;
             ctx.msg  = std::string(path) + "\nFailed to rename the output G-code file: " + ret.message();
             ctx.cancellation_check = [print]() { return print->canceled(); };
@@ -2712,7 +2716,8 @@ void GCode::do_export(Print* print, const char* path, GCodeProcessorResult* resu
 
     {
         LifecycleEventContext ctx;
-        ctx.name = std::to_string(print->model().id().id);
+        ctx.id = std::to_string(print->model().id().id);
+        ctx.name = print->get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.msg  = path;
         ctx.cancellation_check = [print]() { return print->canceled(); };

src/libslic3r/Print.cpp

@@ -2717,7 +2717,8 @@ void Print::process(long long *time_cost_with_cache, bool use_cache)
 
     {
         LifecycleEventContext ctx;
-        ctx.name = std::to_string(m_model.id().id);
+        ctx.id = std::to_string(m_model.id().id);
+        ctx.name = get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.cancellation_check = [this]() { return canceled(); };
         fire_lifecycle_event(LifecycleEvent::SliceStarted, ctx);
@@ -3344,7 +3345,8 @@ void Print::process(long long *time_cost_with_cache, bool use_cache)
 
     {
         LifecycleEventContext ctx;
-        ctx.name = std::to_string(m_model.id().id);
+        ctx.id = std::to_string(m_model.id().id);
+        ctx.name = get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.cancellation_check = [this]() { return canceled(); };
         fire_lifecycle_event(LifecycleEvent::SliceGeometryFinished, ctx);
@@ -4950,7 +4952,8 @@ void Print::export_gcode_from_previous_file(const std::string& file, GCodeProces
 {
     {
         LifecycleEventContext ctx;
-        ctx.name = std::to_string(m_model.id().id);
+        ctx.id = std::to_string(m_model.id().id);
+        ctx.name = get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.msg  = file;
         ctx.cancellation_check = [this]() { return canceled(); };
@@ -4980,7 +4983,8 @@ void Print::export_gcode_from_previous_file(const std::string& file, GCodeProces
         BOOST_LOG_TRIVIAL(error) << __FUNCTION__ <<  boost::format(": found errors when process gcode file %1%") %file.c_str();
         {
             LifecycleEventContext ctx;
-            ctx.name = std::to_string(m_model.id().id);
+            ctx.id = std::to_string(m_model.id().id);
+            ctx.name = get_model_name();
             ctx.code = LifecycleEvtCode::Error;
             ctx.msg  = file + "\n" + ex.what();
             ctx.cancellation_check = [this]() { return canceled(); };
@@ -4994,7 +4998,8 @@ void Print::export_gcode_from_previous_file(const std::string& file, GCodeProces
 
     {
         LifecycleEventContext ctx;
-        ctx.name = std::to_string(m_model.id().id);
+        ctx.id = std::to_string(m_model.id().id);
+        ctx.name = get_model_name();
         ctx.code = LifecycleEvtCode::Ok;
         ctx.msg  = file;
         ctx.cancellation_check = [this]() { return canceled(); };

src/libslic3r/Utils.hpp

@@ -260,11 +260,6 @@ extern bool is_json_file(const std::string& path);
 // Both '/' and '\\' are treated as separators on every platform, so an archive rejected on one OS
 // is rejected on all of them.
 extern bool is_path_within_root(const std::string &rel_path, const boost::filesystem::path &root);
-// True if path names an entry strictly inside root: it must be spelled with root as its prefix,
-// and must still resolve inside root once symlinks are followed.
-extern bool is_absolute_path_within_root(const boost::filesystem::path &path, const boost::filesystem::path &root);
-// True if opening a file with this name through the desktop would run it as a program or script.
-extern bool is_executable_file_name(const std::string &file_name);
 
 // Orca: custom protocal support utils
 inline bool is_orca_open(const std::string& url) { return boost::starts_with(url, "orcaslicer://open"); }

src/libslic3r/utils.cpp

@@ -70,7 +70,6 @@
 #include <boost/shared_ptr.hpp>
 
 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/case_conv.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/path.hpp>
 #include <boost/nowide/fstream.hpp>
@@ -1113,34 +1112,6 @@ bool is_path_within_root(const std::string &rel_path, const boost::filesystem::p
     }
 }
 
-bool is_absolute_path_within_root(const boost::filesystem::path &path, const boost::filesystem::path &root)
-{
-    const boost::filesystem::path rel = path.lexically_relative(root);
-    return !rel.empty() && rel != "." && is_path_within_root(rel.string(), root);
-}
-
-bool is_executable_file_name(const std::string &file_name)
-{
-    static const std::vector<std::string> executable_extensions = {
-        // Windows
-        "exe", "com", "bat", "cmd", "scr", "pif", "msi", "msp", "msc", "cpl", "lnk", "url", "hta", "js", "jse", "vbs",
-        "vbe", "wsf", "wsh", "ps1", "psm1", "reg", "jar", "appref-ms", "scf", "inf", "py", "pyw",
-        // macOS
-        "app", "command", "pkg", "terminal", "workflow",
-        // Linux
-        "sh", "bash", "run", "desktop", "appimage"};
-    // Windows ignores trailing dots and spaces, so "setup.exe." still runs as an .exe.
-    const size_t end = file_name.find_last_not_of(". ");
-    if (end == std::string::npos)
-        return false;
-    const std::string name = file_name.substr(0, end + 1);
-    const size_t      dot  = name.find_last_of('.');
-    if (dot == std::string::npos || name.find_first_of("/\\", dot) != std::string::npos)
-        return false;
-    const std::string extension = boost::algorithm::to_lower_copy(name.substr(dot + 1));
-    return std::find(executable_extensions.begin(), executable_extensions.end(), extension) != executable_extensions.end();
-}
-
 bool is_img_file(const std::string &path)
 {
 	return boost::iends_with(path, ".png") || boost::iends_with(path, ".svg");

src/slic3r/GUI/Plater.cpp

@@ -12800,8 +12800,6 @@ void Plater::priv::on_process_completed(SlicingProcessCompletedEvent &evt)
     notification_manager->set_slicing_progress_export_possible();
 
     // Reset the "export G-code path" name, so that the automatic background processing will be enabled again.
-    const std::string lifecycle_job_name = this->background_process.fff_print() ?
-        this->background_process.fff_print()->output_filename() : std::string();
     this->background_process.reset_export();
     // This bool stops showing export finished notification even when process_completed_with_error is false
     bool has_error = false;
@@ -12848,8 +12846,18 @@ void Plater::priv::on_process_completed(SlicingProcessCompletedEvent &evt)
 
     {
         Slic3r::LifecycleEventContext ctx;
-        ctx.name = lifecycle_job_name;
-        ctx.code = evt.cancelled() ? Slic3r::LifecycleEvtCode::Warn : (has_error ? Slic3r::LifecycleEvtCode::Error : Slic3r::LifecycleEvtCode::Ok);
+        if (const PrintBase* print = this->background_process.current_print()) {
+            const Model& model = print->model();
+            ctx.id             = std::to_string(model.id().id);
+            if (model.model_info)
+                ctx.name = model.model_info->model_name;
+        } else {
+            // Realistically Printbase* print will never be null because select_technology already asserts an active print
+            // and the worker thread asserts it before processing.
+            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": slicing completed without an active print; lifecycle event has no model ID";
+        }
+        ctx.code = evt.cancelled() ? Slic3r::LifecycleEvtCode::Warn :
+                                     (has_error ? Slic3r::LifecycleEvtCode::Error : Slic3r::LifecycleEvtCode::Ok);
         ctx.msg  = evt.cancelled() ? "cancelled" : (has_error ? lifecycle_error_msg : std::string());
         Slic3r::fire_lifecycle_event(Slic3r::LifecycleEvent::SlicingJobComplete, ctx);
     }

src/slic3r/GUI/Project.cpp

@@ -27,7 +27,6 @@
 #include "GUI_App.hpp"
 #include "GUI_ObjectList.hpp"
 #include "MainFrame.hpp"
-#include "MsgDialog.hpp"
 #include <slic3r/GUI/Widgets/WebView.hpp>
 
 namespace Slic3r { namespace GUI {
@@ -294,24 +293,9 @@ void ProjectPanel::OnScriptMessage(wxWebViewEvent& evt)
             if (!accessory_path.empty()) {
                 std::string decode_path = wxGetApp().url_decode(accessory_path.ToStdString());
                 fs::path path(decode_path);
-                // Only open the project's own extracted auxiliary files, with the root built as in Reload().
-                fs::path aux_root(encode_path(wxGetApp().plater()->model().get_auxiliary_file_temp_path().c_str()));
 
-                if (is_absolute_path_within_root(path, aux_root) && fs::is_regular_file(path)) {
-                    // Attachments come with the project, so ask before running one that is a program or script.
-                    bool open = true;
-                    if (is_executable_file_name(path.filename().string())) {
-                        MessageDialog dlg(this,
-                                          wxString::Format(_L("\"%s\" is a program or script. Opening it will run it on this computer.\n\n"
-                                                              "Only open attachments from projects you trust. Open it anyway?"),
-                                                           from_path(path.filename())),
-                                          _L("Open attachment"), wxICON_WARNING | wxYES_NO);
-                        open = dlg.ShowModal() == wxID_YES;
-                    }
-                    if (open)
-                        wxLaunchDefaultApplication(path.wstring(), 0);
-                } else {
-                    BOOST_LOG_TRIVIAL(warning) << "open_3mf_accessory: ignoring path outside the project auxiliary directory: " << decode_path;
+                if (fs::exists(path)) {
+                    wxLaunchDefaultApplication(path.wstring(), 0);
                 }
             }
         }

src/slic3r/Utils/PrintHost.cpp

@@ -6,6 +6,7 @@
 #include <boost/optional.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/filesystem.hpp>
+#include <nlohmann/json.hpp>
 
 #include <wx/string.h>
 #include <wx/app.h>
@@ -115,10 +116,67 @@ std::string PrintHost::get_print_host_webui(DynamicPrintConfig* config)
     return webui_url;
 }
 
+namespace {
+
+// Moonraker (Klipper's API server) reports a raised exception as { "error": { "code", "message", "traceback" } }
+// under every host type that connects to it, often with the cause only in the traceback. Returns the reason to show,
+// or empty for any other body.
+std::string moonraker_error_reason(const std::string &body)
+{
+    const auto root = nlohmann::json::parse(body, nullptr, false);
+    const auto err  = root.find("error");
+    if (err == root.end())
+        return {};
+    const auto message   = err->find("message");
+    const auto traceback = err->find("traceback");
+    if (message == err->end() || traceback == err->end() || !message->is_string() || !traceback->is_string())
+        return {};
+
+    const auto &msg = message->get_ref<const std::string &>();
+    const auto &tb  = traceback->get_ref<const std::string &>();
+    if (msg.empty())
+        return {};
+    const auto end = tb.find_last_not_of(" \t\r\n");
+    if (end == std::string::npos)
+        return msg;
+
+    // Chained exceptions each start a new traceback; the one that failed the request is the last.
+    const auto header = tb.rfind("Traceback (most recent call last):", end);
+
+    // Tornado renders a raised HTTPError as "HTTP <code>: <reason>[ (<detail>)]", and the detail may span lines.
+    const auto code = err->find("code");
+    if (code != err->end() && code->is_number_integer()) {
+        const std::string marker = "HTTP " + std::to_string(code->get<int>()) + ": ";
+        const auto        pos    = tb.rfind(marker, end);
+        if (pos != std::string::npos && (header == std::string::npos || pos > header) && pos + marker.size() <= end) {
+            const std::string reason = tb.substr(pos + marker.size(), end + 1 - pos - marker.size());
+            // An HTTPError whose detail equals its reason, like HTTPError(401, "Unauthorized"), renders the phrase twice.
+            return reason == msg + " (" + msg + ")" ? msg : reason;
+        }
+    }
+
+    // Any other exception's type and message are everything from the first unindented line after its frames.
+    auto begin = (header == std::string::npos) ? std::string::npos : tb.find('\n', header);
+    while (begin != std::string::npos && begin < end) {
+        ++begin;
+        if (tb[begin] != ' ' && tb[begin] != '\r' && tb[begin] != '\n')
+            break;
+        begin = tb.find('\n', begin);
+    }
+    if (begin == std::string::npos || begin > end) {
+        const auto nl = tb.rfind('\n', end);
+        begin         = (nl == std::string::npos) ? 0 : nl + 1;
+    }
+    return msg + " (" + tb.substr(begin, end + 1 - begin) + ")";
+}
+
+} // namespace
+
 wxString PrintHost::format_error(const std::string &body, const std::string &error, unsigned status) const
 {
     if (status != 0) {
-        auto wxbody = wxString::FromUTF8(body.data());
+        const std::string reason = moonraker_error_reason(body);
+        auto wxbody = wxString::FromUTF8(reason.empty() ? body : reason);
         return wxString::Format("HTTP %u: %s", status, wxbody);
     } else {
         if (error.find("curl:Timeout was reached") != std::string::npos) {

tests/fff_print/test_print.cpp

@@ -15,6 +15,9 @@
 #include "libslic3r/Layer.hpp"
 #include "libslic3r/Model.hpp"
 #include "libslic3r/GCodeReader.hpp"
+#include "libslic3r/GCode/GCodeProcessor.hpp"
+#include "libslic3r/Exception.hpp"
+#include "libslic3r/LifecycleEvents.hpp"
 
 #include "test_helpers.hpp"
 #include "test_utils.hpp"
@@ -22,7 +25,10 @@
 #include <algorithm>
 #include <fstream>
 #include <iterator>
+#include <memory>
 #include <string_view>
+#include <utility>
+#include <vector>
 
 using namespace Slic3r;
 using namespace Slic3r::Test;
@@ -224,8 +230,88 @@ std::string resolved_output_name(Model& model, const std::string& format, const
     return print.output_filename(filename_base);
 }
 
+struct ScopedLifecycleHook
+{
+    explicit ScopedLifecycleHook(LifecycleHookFn hook) { set_lifecycle_hook_fn(std::move(hook)); }
+    ~ScopedLifecycleHook() { set_lifecycle_hook_fn(nullptr); }
+};
+
 } // namespace
 
+TEST_CASE("Slicing lifecycle events identify the model", "[Print][LifecycleEvents]")
+{
+    struct ObservedEvent {
+        LifecycleEvent event;
+        std::string id;
+        std::string name;
+    };
+    std::vector<ObservedEvent> events;
+    ScopedLifecycleHook hook([&](LifecycleEvent event, const LifecycleEventContext& ctx) {
+        events.push_back({ event, ctx.id, ctx.name });
+    });
+
+    Print print;
+    Model model;
+    ModelInfo info;
+    info.model_name = "Lifecycle test model";
+    model.model_info = std::make_shared<ModelInfo>(std::move(info));
+    init_print({cube(20)}, print, model);
+
+    print.process();
+    ScopedTemporaryFile temp(".gcode");
+    print.export_gcode(temp.string(), nullptr, nullptr);
+    GCodeProcessorResult result;
+    print.export_gcode_from_previous_file(temp.string(), &result);
+
+    const std::string expected_id = std::to_string(print.model().id().id);
+    const std::vector<LifecycleEvent> expected_events = {
+        LifecycleEvent::SliceStarted,
+        LifecycleEvent::SliceGeometryFinished,
+        LifecycleEvent::GCodeExportStarted,
+        LifecycleEvent::GCodeExportFinished,
+        LifecycleEvent::GCodeExportStarted,
+        LifecycleEvent::GCodeExportFinished,
+    };
+    REQUIRE(events.size() == expected_events.size());
+    for (size_t i = 0; i < expected_events.size(); ++i) {
+        CHECK(events[i].event == expected_events[i]);
+        CHECK(events[i].id == expected_id);
+        CHECK(events[i].name == "Lifecycle test model");
+    }
+}
+
+TEST_CASE("Slicing lifecycle event name is empty without model metadata", "[Print][LifecycleEvents]")
+{
+    std::string event_id;
+    std::string event_name = "unset";
+    ScopedLifecycleHook hook([&](LifecycleEvent event, const LifecycleEventContext& ctx) {
+        if (event == LifecycleEvent::SliceStarted) {
+            event_id = ctx.id;
+            event_name = ctx.name;
+        }
+    });
+
+    Print print;
+    Model model;
+    init_print({cube(20)}, print, model);
+    print.process();
+
+    CHECK(event_id == std::to_string(print.model().id().id));
+    CHECK(event_name.empty());
+}
+
+TEST_CASE("Output filenames with numeric statistics fail before slicing finishes", "[Print][Regression]")
+{
+    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+    config.set_key_value("filename_format", new ConfigOptionString("{int(total_weight*10) / 10.0}"));
+
+    Print print;
+    Model model;
+    init_print({cube(20)}, print, model, config);
+
+    CHECK_THROWS_AS(print.output_filename(), PlaceholderParserError);
+}
+
 TEST_CASE("Print: {first_object_name} names the first printable object on the plate", "[Print]")
 {
     Model model;

tests/libslic3r/CMakeLists.txt

@@ -14,6 +14,7 @@ add_executable(${_TEST_NAME}_tests
     test_clipper_utils.cpp
     test_config.cpp
     test_config_variant_expansion.cpp
+    test_drc.cpp
     test_toolordering_nozzle_group.cpp
     test_preset_bundle_loading.cpp
     test_preset_setting_id.cpp
@@ -32,6 +33,7 @@ add_executable(${_TEST_NAME}_tests
     test_mutable_priority_queue.cpp
     test_minimum_spanning_tree.cpp
     test_nozzle_volume_type.cpp
+    test_obj.cpp
     test_step.cpp
     test_stl.cpp
     test_triangle_selector.cpp
@@ -67,7 +69,9 @@ if (TARGET OpenVDB::openvdb)
     target_sources(${_TEST_NAME}_tests PRIVATE test_hollowing.cpp)
 endif()
 
-target_link_libraries(${_TEST_NAME}_tests test_common libslic3r Catch2::Catch2WithMain)
+# libslic3r links Draco privately; test_drc.cpp encodes its own fixtures.
+find_package(Draco REQUIRED)
+target_link_libraries(${_TEST_NAME}_tests test_common libslic3r draco::draco Catch2::Catch2WithMain)
 target_include_directories(${_TEST_NAME}_tests PRIVATE ${CMAKE_SOURCE_DIR}/src)
 set_property(TARGET ${_TEST_NAME}_tests PROPERTY FOLDER "tests")
 

tests/libslic3r/test_drc.cpp

@@ -0,0 +1,71 @@
+#include <catch2/catch_all.hpp>
+
+#include "libslic3r/Format/DRC.hpp"
+#include "libslic3r/TriangleMesh.hpp"
+
+#include <boost/nowide/fstream.hpp>
+
+#include <draco/compression/encode.h>
+#include <draco/mesh/mesh.h>
+
+#include "test_utils.hpp"
+
+using namespace Slic3r;
+
+namespace {
+
+// Encodes one triangle whose vertices carry a single attribute of the given type.
+// The decoder accepts both a mesh without POSITION and a face index past the point count.
+void write_drc_triangle(const std::string &path, draco::GeometryAttribute::Type attribute_type, uint32_t second_point)
+{
+    draco::Mesh mesh;
+    mesh.set_num_points(3);
+    draco::GeometryAttribute attribute;
+    attribute.Init(attribute_type, nullptr, 3, draco::DT_FLOAT32, false, sizeof(float) * 3, 0);
+    const int attribute_id = mesh.AddAttribute(attribute, true, 3);
+    const float points[3][3] = {{0, 0, 0}, {1, 0, 0}, {0, 1, 0}};
+    for (int i = 0; i < 3; ++i)
+        mesh.attribute(attribute_id)->SetAttributeValue(draco::AttributeValueIndex(i), points[i]);
+    draco::Mesh::Face face;
+    face[0] = draco::PointIndex(0);
+    face[1] = draco::PointIndex(second_point);
+    face[2] = draco::PointIndex(2);
+    mesh.AddFace(face);
+
+    draco::Encoder encoder;
+    encoder.SetEncodingMethod(draco::MESH_SEQUENTIAL_ENCODING);
+    draco::EncoderBuffer buffer;
+    REQUIRE(encoder.EncodeMeshToBuffer(mesh, &buffer).ok());
+    boost::nowide::ofstream out(path, std::ios::binary);
+    out.write(buffer.data(), static_cast<std::streamsize>(buffer.size()));
+}
+
+} // namespace
+
+TEST_CASE("A Draco triangle with positions loads", "[DRC]")
+{
+    ScopedTemporaryFile drc(".drc");
+    write_drc_triangle(drc.string(), draco::GeometryAttribute::POSITION, 1);
+
+    TriangleMesh mesh;
+    REQUIRE(load_drc(drc.string().c_str(), &mesh));
+    CHECK(mesh.facets_count() == 1);
+}
+
+TEST_CASE("A Draco mesh without a POSITION attribute fails to load", "[DRC][Regression]")
+{
+    ScopedTemporaryFile drc(".drc");
+    write_drc_triangle(drc.string(), draco::GeometryAttribute::GENERIC, 1);
+
+    TriangleMesh mesh;
+    CHECK_FALSE(load_drc(drc.string().c_str(), &mesh));
+}
+
+TEST_CASE("A Draco face referencing a missing point fails to load", "[DRC][Regression]")
+{
+    ScopedTemporaryFile drc(".drc");
+    write_drc_triangle(drc.string(), draco::GeometryAttribute::POSITION, 200);
+
+    TriangleMesh mesh;
+    CHECK_FALSE(load_drc(drc.string().c_str(), &mesh));
+}

tests/libslic3r/test_obj.cpp

@@ -0,0 +1,122 @@
+#include <catch2/catch_all.hpp>
+
+#include "libslic3r/TriangleMesh.hpp"
+#include "libslic3r/Format/OBJ.hpp"
+
+#include <boost/nowide/fstream.hpp>
+
+#include "test_utils.hpp"
+
+using namespace Slic3r;
+using Catch::Matchers::WithinAbs;
+
+namespace {
+
+struct LoadedObj
+{
+    bool         ok{false};
+    TriangleMesh mesh;
+    ObjInfo      info;
+};
+
+// A tetrahedron with a material and two texture coordinates, (0.25, 0.5) and (0.75, 1).
+// Only the first face and the vt lines are varied; the other three faces reference vt 1.
+LoadedObj load_textured_tetrahedron(const std::string &first_face, const std::string &vts = "vt 0.25 0.5\nvt 0.75 1\n")
+{
+    ScopedTemporaryFile obj(".obj");
+    ScopedTemporaryFile mtl(".mtl");
+    {
+        boost::nowide::ofstream out(mtl.string());
+        out << "newmtl a\nKd 1 0 0\n";
+    }
+    {
+        boost::nowide::ofstream out(obj.string());
+        out << "mtllib " << mtl.path().filename().string() << "\n"
+            << "v 0 0 0\nv 10 0 0\nv 0 10 0\nv 0 0 10\n"
+            << vts
+            << "usemtl a\n"
+            << first_face << "\n"
+            << "f 1/1 2/1 4/1\nf 1/1 4/1 3/1\nf 2/1 3/1 4/1\n";
+    }
+    LoadedObj   loaded;
+    std::string message;
+    loaded.ok = load_obj(obj.string().c_str(), &loaded.mesh, loaded.info, message);
+    return loaded;
+}
+
+} // namespace
+
+TEST_CASE("An out-of-range texture index falls back to a zero UV and keeps the geometry", "[OBJ][Regression]")
+{
+    const LoadedObj loaded = load_textured_tetrahedron("f 1/1000000000 3/1 2/1");
+
+    REQUIRE(loaded.ok);
+    CHECK(loaded.mesh.facets_count() == 4);
+    REQUIRE(loaded.info.uvs.size() == 4);
+    const std::array<Vec2f, 3> &uv = loaded.info.uvs.front();
+    CHECK_THAT(uv[0].x(), WithinAbs(0., 1e-6));
+    CHECK_THAT(uv[0].y(), WithinAbs(0., 1e-6));
+    CHECK_THAT(uv[1].x(), WithinAbs(0.25, 1e-6));
+    CHECK_THAT(uv[1].y(), WithinAbs(0.5, 1e-6));
+}
+
+TEST_CASE("A face without texture indices loads among faces that have them", "[OBJ][Regression]")
+{
+    const LoadedObj loaded = load_textured_tetrahedron("f 1 3 2");
+
+    REQUIRE(loaded.ok);
+    CHECK(loaded.mesh.facets_count() == 4);
+    // One UV entry per face, so later faces keep their own coordinates.
+    REQUIRE(loaded.info.uvs.size() == 4);
+    for (const Vec2f &uv : loaded.info.uvs.front()) {
+        CHECK_THAT(uv.x(), WithinAbs(0., 1e-6));
+        CHECK_THAT(uv.y(), WithinAbs(0., 1e-6));
+    }
+    CHECK_THAT(loaded.info.uvs[1][0].x(), WithinAbs(0.25, 1e-6));
+    CHECK_THAT(loaded.info.uvs[1][0].y(), WithinAbs(0.5, 1e-6));
+}
+
+TEST_CASE("A negative texture index counts back from the last texture coordinate", "[OBJ]")
+{
+    // -1 is the most recent vt (0.75, 1), -2 the one before it (0.25, 0.5).
+    const LoadedObj loaded = load_textured_tetrahedron("f 1/-2 3/-1 2/-1");
+
+    REQUIRE(loaded.ok);
+    CHECK(loaded.mesh.facets_count() == 4);
+    REQUIRE(loaded.info.uvs.size() == 4);
+    const std::array<Vec2f, 3> &uv = loaded.info.uvs.front();
+    CHECK_THAT(uv[0].x(), WithinAbs(0.25, 1e-6));
+    CHECK_THAT(uv[0].y(), WithinAbs(0.5, 1e-6));
+    CHECK_THAT(uv[1].x(), WithinAbs(0.75, 1e-6));
+    CHECK_THAT(uv[1].y(), WithinAbs(1., 1e-6));
+}
+
+TEST_CASE("Texture coordinates with a w component are kept", "[OBJ][Regression]")
+{
+    const LoadedObj loaded = load_textured_tetrahedron("f 1/1 3/2 2/2", "vt 0.25 0.5 0\nvt 0.75 1 0\n");
+
+    REQUIRE(loaded.ok);
+    CHECK(loaded.mesh.facets_count() == 4);
+    REQUIRE(loaded.info.uvs.size() == 4);
+    const std::array<Vec2f, 3> &uv = loaded.info.uvs.front();
+    CHECK_THAT(uv[0].x(), WithinAbs(0.25, 1e-6));
+    CHECK_THAT(uv[0].y(), WithinAbs(0.5, 1e-6));
+    CHECK_THAT(uv[1].x(), WithinAbs(0.75, 1e-6));
+    CHECK_THAT(uv[1].y(), WithinAbs(1., 1e-6));
+}
+
+TEST_CASE("A texture coordinate with w does not shift the indices of the ones after it", "[OBJ][Regression]")
+{
+    // The w on the first vt used to drop that line, so vt 2 resolved to the third coordinate.
+    const LoadedObj loaded = load_textured_tetrahedron("f 1/2 3/3 2/-1", "vt 0.1 0.2 0\nvt 0.25 0.5\nvt 0.75 1\n");
+
+    REQUIRE(loaded.ok);
+    REQUIRE(loaded.info.uvs.size() == 4);
+    const std::array<Vec2f, 3> &uv = loaded.info.uvs.front();
+    CHECK_THAT(uv[0].x(), WithinAbs(0.25, 1e-6));
+    CHECK_THAT(uv[0].y(), WithinAbs(0.5, 1e-6));
+    CHECK_THAT(uv[1].x(), WithinAbs(0.75, 1e-6));
+    CHECK_THAT(uv[1].y(), WithinAbs(1., 1e-6));
+    CHECK_THAT(uv[2].x(), WithinAbs(0.75, 1e-6));
+    CHECK_THAT(uv[2].y(), WithinAbs(1., 1e-6));
+}

tests/libslic3r/test_utils.cpp

@@ -152,65 +152,3 @@ TEST_CASE("resolve_cli_input_path leaves inputs that must not be completed uncha
         REQUIRE(resolve_cli_input_path("").empty());
     }
 }
-
-TEST_CASE("is_absolute_path_within_root accepts only entries inside the root", "[utils]") {
-    namespace fs = boost::filesystem;
-    ScopedTemporaryDir outer;
-    const fs::path root = outer.path() / "Auxiliaries";
-    fs::create_directories(root / "Others");
-    const fs::path inside = root / "Others" / "note.txt";
-    const fs::path outside = outer.path() / "secret.txt";
-    std::ofstream(inside.string()) << "inside";
-    std::ofstream(outside.string()) << "outside";
-
-    SECTION("a file inside the root") {
-        REQUIRE(is_absolute_path_within_root(inside, root));
-    }
-    SECTION("a path inside the root whose file does not exist yet") {
-        REQUIRE(is_absolute_path_within_root(root / "Others" / "missing.txt", root));
-    }
-    SECTION("the root itself") {
-        REQUIRE_FALSE(is_absolute_path_within_root(root, root));
-    }
-    SECTION("a parent-directory escape spelled under the root") {
-        REQUIRE_FALSE(is_absolute_path_within_root(root / "Others" / ".." / ".." / "secret.txt", root));
-    }
-    SECTION("an absolute path elsewhere") {
-        REQUIRE_FALSE(is_absolute_path_within_root(outside, root));
-    }
-    SECTION("a sibling directory sharing the root's name as a prefix") {
-        const fs::path sibling = outer.path() / "Auxiliaries2" / "note.txt";
-        REQUIRE_FALSE(is_absolute_path_within_root(sibling, root));
-    }
-    SECTION("a relative path") {
-        REQUIRE_FALSE(is_absolute_path_within_root(fs::path("Others") / "note.txt", root));
-    }
-    SECTION("an empty path") {
-        REQUIRE_FALSE(is_absolute_path_within_root(fs::path(), root));
-    }
-#ifndef _WIN32
-    // Creating symlinks on Windows needs elevated rights or developer mode.
-    SECTION("a symlink inside the root that points outside") {
-        const fs::path link = root / "Others" / "link.txt";
-        fs::create_symlink(outside, link);
-        REQUIRE_FALSE(is_absolute_path_within_root(link, root));
-    }
-#endif
-}
-
-TEST_CASE("is_executable_file_name flags attachments that would run as programs", "[utils]") {
-    const std::string executable = GENERATE(as<std::string>{},
-        "setup.exe", "SETUP.EXE", "Manual.pdf.exe", "run.bat", "start.cmd", "shortcut.lnk", "site.url", "script.ps1",
-        "macro.vbs", "tool.jar", "script.py", "Install.command", "Tool.app", "installer.pkg", "install.sh",
-        "launcher.desktop", "Printer.AppImage", "setup.exe.", "setup.exe ", "setup.exe. .", ".exe");
-    INFO(executable);
-    CHECK(is_executable_file_name(executable));
-}
-
-TEST_CASE("is_executable_file_name leaves documents and models alone", "[utils]") {
-    const std::string document = GENERATE(as<std::string>{},
-        "Manual.pdf", "BOM.xlsx", "notes.txt", "photo.JPG", "assembly.step", "part.stl", "project.3mf", "readme",
-        "exe", "setup.exe.pdf", "", "...", "dir.exe/readme");
-    INFO(document);
-    CHECK_FALSE(is_executable_file_name(document));
-}

tests/slic3rutils/CMakeLists.txt

@@ -18,6 +18,7 @@ add_executable(${_TEST_NAME}_tests
     test_plugin_install.cpp
     test_plugin_lifecycle.cpp
     test_plugin_printer_agent.cpp
+    test_printhost.cpp
     test_slicing_pipeline_bindings.cpp
     test_slicing_pipeline_config.cpp
     test_plugin_sort.cpp

tests/slic3rutils/test_printhost.cpp

@@ -0,0 +1,213 @@
+#include <catch2/catch_all.hpp>
+
+#include <nlohmann/json.hpp>
+
+#include "slic3r/Utils/PrintHost.hpp"
+
+using namespace Slic3r;
+
+namespace {
+
+class TestPrintHost : public PrintHost
+{
+public:
+    using PrintHost::format_error;
+
+    const char* get_name() const override { return "Test"; }
+    bool test(wxString&) const override { return true; }
+    wxString get_test_ok_msg() const override { return {}; }
+    wxString get_test_failed_msg(wxString&) const override { return {}; }
+    bool upload(PrintHostUpload, ProgressFn, ErrorFn, InfoFn) const override { return true; }
+    bool has_auto_discovery() const override { return false; }
+    bool can_test() const override { return false; }
+    PrintHostPostUploadActions get_post_upload_actions() const override { return {}; }
+    std::string get_host() const override { return {}; }
+};
+
+std::string format_error(const std::string& body, const std::string& error, unsigned status)
+{
+    return TestPrintHost().format_error(body, error, status).ToStdString();
+}
+
+std::string envelope(int code, const std::string& message, const std::string& traceback)
+{
+    return nlohmann::json{{"error", {{"code", code}, {"message", message}, {"traceback", traceback}}}}.dump();
+}
+
+std::string moonraker_error(int code, const std::string& message, const std::string& detail = {})
+{
+    std::string line = "tornado.web.HTTPError: HTTP " + std::to_string(code) + ": " + message;
+    if (!detail.empty())
+        line += " (" + detail + ")";
+    return envelope(code, message, "Traceback (most recent call last):\n  ...\n" + line + "\n");
+}
+
+// A real Moonraker body for uploading a file that is being printed.
+constexpr const char* k_busy_file_403 =
+    R"JSON({"error": {"code": 403, "message": "Forbidden", "traceback": "Traceback (most recent call last):\n\n  File \"/home/lava/moonraker/moonraker/components/file_manager/file_manager.py\", line 1017, in _finish_gcode_upload\n    can_start = self._handle_operation_check(check_path)\n                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nmoonraker.utils.exceptions.ServerError: File currently in use\n\nDuring handling of the above exception, another exception occurred:\n\nTraceback (most recent call last):\n\n  File \"/home/lava/moonraker/moonraker/components/application.py\", line 1069, in post\n    raise tornado.web.HTTPError(\ntornado.web.HTTPError: HTTP 403: Forbidden (File is loaded, upload not permitted)\n"}})JSON";
+
+} // namespace
+
+TEST_CASE("A Klipper upload error shows its reason instead of a Python traceback", "[PrintHost][Regression]")
+{
+    const std::string msg = format_error(k_busy_file_403, "", 403);
+    INFO("actual: " << msg);
+
+    CHECK(msg == "HTTP 403: Forbidden (File is loaded, upload not permitted)");
+    CHECK_THAT(msg, !Catch::Matchers::ContainsSubstring("Traceback"));
+    CHECK_THAT(msg, !Catch::Matchers::ContainsSubstring("file_manager.py"));
+}
+
+TEST_CASE("The specific cause is recovered from a file endpoint's traceback", "[PrintHost]")
+{
+    SECTION("a plain detail")
+    {
+        const std::string body = moonraker_error(403, "Forbidden", "File is loaded, upload not permitted");
+        CHECK(format_error(body, "", 403) == "HTTP 403: Forbidden (File is loaded, upload not permitted)");
+    }
+
+    SECTION("a detail whose own parentheses nest (a filename)")
+    {
+        const std::string detail = "Directory does not exist (/home/pi/gcodes/plate (1).gcode)";
+        const std::string body   = moonraker_error(400, "Bad Request", detail);
+        CHECK(format_error(body, "", 400) == "HTTP 400: Bad Request (" + detail + ")");
+    }
+
+    SECTION("a detail that contains the reason phrase")
+    {
+        const std::string body = moonraker_error(403, "Forbidden", "Forbidden zone: access denied");
+        CHECK(format_error(body, "", 403) == "HTTP 403: Forbidden (Forbidden zone: access denied)");
+    }
+
+    SECTION("a detail that spans lines")
+    {
+        const std::string detail = "Move out of range\nX=250.000 Y=10.000";
+        const std::string body   = moonraker_error(400, "Bad Request", detail);
+        CHECK(format_error(body, "", 400) == "HTTP 400: Bad Request (" + detail + ")");
+    }
+
+    SECTION("a detail that only repeats the reason phrase is dropped")
+    {
+        const std::string body = moonraker_error(401, "Unauthorized", "Unauthorized");
+        CHECK(format_error(body, "", 401) == "HTTP 401: Unauthorized");
+    }
+}
+
+TEST_CASE("An unhandled exception shows its type and message", "[PrintHost]")
+{
+    const std::string frame = "Traceback (most recent call last):\n"
+                              "  File \"/home/pi/moonraker/moonraker/components/file_manager/file_manager.py\", line 1, in write\n"
+                              "    self._write(data)\n";
+
+    SECTION("a one-line message")
+    {
+        const std::string body = envelope(500, "Internal Server Error", frame + "OSError: [Errno 28] No space left on device\n");
+        CHECK(format_error(body, "", 500) == "HTTP 500: Internal Server Error (OSError: [Errno 28] No space left on device)");
+    }
+
+    SECTION("a message that spans lines")
+    {
+        const std::string body = envelope(500, "Internal Server Error", frame + "ServerError: Klippy request failed\n  see klippy.log\n");
+        CHECK(format_error(body, "", 500) == "HTTP 500: Internal Server Error (ServerError: Klippy request failed\n  see klippy.log)");
+    }
+
+    SECTION("raised while handling an HTTPError with the same code")
+    {
+        const std::string traceback = frame + "tornado.web.HTTPError: HTTP 500: Internal Server Error (Database locked)\n\n"
+                                              "During handling of the above exception, another exception occurred:\n\n" +
+                                      frame + "OSError: [Errno 5] Input/output error\n";
+        const std::string body      = envelope(500, "Internal Server Error", traceback);
+        CHECK(format_error(body, "", 500) == "HTTP 500: Internal Server Error (OSError: [Errno 5] Input/output error)");
+    }
+
+    SECTION("a traceback with no header")
+    {
+        const std::string body = envelope(500, "Internal Server Error", "OSError: [Errno 5] Input/output error");
+        CHECK(format_error(body, "", 500) == "HTTP 500: Internal Server Error (OSError: [Errno 5] Input/output error)");
+    }
+}
+
+TEST_CASE("A reason already complete in message is shown unchanged", "[PrintHost]")
+{
+    SECTION("message is the whole reason, no trailing detail")
+    {
+        const std::string body = moonraker_error(503, "Klippy is not ready");
+        CHECK(format_error(body, "", 503) == "HTTP 503: Klippy is not ready");
+    }
+
+    SECTION("a message that itself contains parentheses is not duplicated")
+    {
+        const std::string reason = "Requested blocks (0-5) are unavailable";
+        const std::string body   = moonraker_error(400, reason);
+        CHECK(format_error(body, "", 400) == "HTTP 400: " + reason);
+    }
+}
+
+TEST_CASE("A Moonraker error with no usable detail shows just the reason phrase", "[PrintHost]")
+{
+    struct Case
+    {
+        const char* name;
+        const char* body;
+        unsigned status;
+        const char* expected;
+    };
+
+    const auto c = GENERATE(
+        Case{"an empty traceback", R"JSON({"error": {"code": 500, "message": "Internal Server Error", "traceback": ""}})JSON", 500,
+             "HTTP 500: Internal Server Error"},
+        Case{"a traceback of only whitespace", R"JSON({"error": {"code": 500, "message": "Internal Server Error", "traceback": "\n \n"}})JSON",
+             500, "HTTP 500: Internal Server Error"});
+
+    DYNAMIC_SECTION(c.name) { CHECK(format_error(c.body, "", c.status) == c.expected); }
+}
+
+TEST_CASE("A percent sign in the reason is not a format specifier", "[PrintHost]")
+{
+    const std::string body = moonraker_error(507, "Insufficient Storage", "disk 100% full");
+    CHECK(format_error(body, "", 507) == "HTTP 507: Insufficient Storage (disk 100% full)");
+}
+
+TEST_CASE("Error bodies that are not a Moonraker envelope are left unchanged", "[PrintHost]")
+{
+    SECTION("OctoPrint's string-valued error member")
+    {
+        const std::string body = R"JSON({"error": "File not found"})JSON";
+        CHECK(format_error(body, "", 404) == "HTTP 404: " + body);
+    }
+
+    SECTION("PrusaLink's top-level message, not under error")
+    {
+        const std::string body = R"JSON({"title": "Conflict", "message": "Printer is printing"})JSON";
+        CHECK(format_error(body, "", 409) == "HTTP 409: " + body);
+    }
+
+    SECTION("a body that is not JSON")
+    {
+        const std::string html = "<html><head><title>502 Bad Gateway</title></head></html>";
+        CHECK(format_error(html, "", 502) == "HTTP 502: " + html);
+    }
+
+    SECTION("an error object with no traceback")
+    {
+        const std::string body = R"JSON({"error": {"code": 500, "message": "Internal Server Error"}})JSON";
+        CHECK(format_error(body, "", 500) == "HTTP 500: " + body);
+    }
+
+    SECTION("an error object whose traceback is null")
+    {
+        const std::string body = R"JSON({"error": {"code": 500, "message": "Internal Server Error", "traceback": null}})JSON";
+        CHECK(format_error(body, "", 500) == "HTTP 500: " + body);
+    }
+
+    SECTION("an envelope whose reason phrase is empty")
+    {
+        const std::string body = envelope(403, "", "Traceback (most recent call last):\nOSError: denied\n");
+        CHECK(format_error(body, "", 403) == "HTTP 403: " + body);
+    }
+
+    SECTION("a transport error with no HTTP status")
+    {
+        CHECK(format_error("", "curl:Could not connect", 0) == "curl:Could not connect");
+    }
+}