Drop Malformed 3MF Paint Data Instead of Reading Past the Bitstream

Painted facets are decoded from a bitstream a nibble at a time with no bound
check, so a truncated or corrupt paint string in a 3MF (for example split
codes with no children behind them) read past the end and crashed on load and
slice. A one- or two-side split naming side 3 also indexed past the triangle's
vertices.

Every nibble read now goes through a bounds-checked reader. Loading validates
each triangle's tree and drops a malformed one with a warning, so the stored
data, used extruder states and later decoding all agree. deserialize() also
unwinds and clears any triangle whose tree is incomplete or malformed, and
has_facets() stops at a truncated triangle. Valid streams decode unchanged.

src/libslic3r/Format/bbs_3mf.cpp

@@ -1629,7 +1629,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         }
         while (it != m_plater_data.end())
         {
-            if (it->first > m_plater_data.size())
+            if (it->first <= 0 || static_cast<size_t>(it->first) > m_plater_data.size())
             {
                 add_error("invalid plate index");
                 return false;
@@ -2312,7 +2312,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         }
         while (it != m_plater_data.end())
         {
-            if (it->first > m_plater_data.size())
+            if (it->first <= 0 || static_cast<size_t>(it->first) > m_plater_data.size())
             {
                 add_error("invalid plate index");
                 return false;

src/libslic3r/GCode.cpp

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

src/libslic3r/Model.cpp

@@ -3702,7 +3702,11 @@ void FacetsAnnotation::set_triangle_from_string(int triangle_id, const std::stri
             m_data.bitstream.insert(m_data.bitstream.end(), bool(dec & (1 << i)));
     }
 
-    m_data.update_used_states(bitstream_start_idx);
+    if (!m_data.update_used_states(bitstream_start_idx)) {
+        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": dropping malformed paint data of triangle " << triangle_id;
+        m_data.bitstream.resize(bitstream_start_idx);
+        m_data.triangles_to_split.pop_back();
+    }
 }
 
 bool FacetsAnnotation::equals(const FacetsAnnotation &other) const

src/libslic3r/Print.cpp

@@ -2717,8 +2717,7 @@ void Print::process(long long *time_cost_with_cache, bool use_cache)
 
     {
         LifecycleEventContext ctx;
-        ctx.id = std::to_string(m_model.id().id);
-        ctx.name = get_model_name();
+        ctx.name = std::to_string(m_model.id().id);
         ctx.code = LifecycleEvtCode::Ok;
         ctx.cancellation_check = [this]() { return canceled(); };
         fire_lifecycle_event(LifecycleEvent::SliceStarted, ctx);
@@ -3345,8 +3344,7 @@ void Print::process(long long *time_cost_with_cache, bool use_cache)
 
     {
         LifecycleEventContext ctx;
-        ctx.id = std::to_string(m_model.id().id);
-        ctx.name = get_model_name();
+        ctx.name = std::to_string(m_model.id().id);
         ctx.code = LifecycleEvtCode::Ok;
         ctx.cancellation_check = [this]() { return canceled(); };
         fire_lifecycle_event(LifecycleEvent::SliceGeometryFinished, ctx);
@@ -4952,8 +4950,7 @@ void Print::export_gcode_from_previous_file(const std::string& file, GCodeProces
 {
     {
         LifecycleEventContext ctx;
-        ctx.id = std::to_string(m_model.id().id);
-        ctx.name = get_model_name();
+        ctx.name = std::to_string(m_model.id().id);
         ctx.code = LifecycleEvtCode::Ok;
         ctx.msg  = file;
         ctx.cancellation_check = [this]() { return canceled(); };
@@ -4983,8 +4980,7 @@ 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.id = std::to_string(m_model.id().id);
-            ctx.name = get_model_name();
+            ctx.name = std::to_string(m_model.id().id);
             ctx.code = LifecycleEvtCode::Error;
             ctx.msg  = file + "\n" + ex.what();
             ctx.cancellation_check = [this]() { return canceled(); };
@@ -4998,8 +4994,7 @@ void Print::export_gcode_from_previous_file(const std::string& file, GCodeProces
 
     {
         LifecycleEventContext ctx;
-        ctx.id = std::to_string(m_model.id().id);
-        ctx.name = get_model_name();
+        ctx.name = std::to_string(m_model.id().id);
         ctx.code = LifecycleEvtCode::Ok;
         ctx.msg  = file;
         ctx.cancellation_check = [this]() { return canceled(); };

src/libslic3r/TriangleSelector.cpp

@@ -1778,6 +1778,13 @@ TriangleSelector::TriangleSplittingData TriangleSelector::serialize() const {
     return out.data;
 }
 
+// A split code keeps the split side (one split) or the kept side (two splits) in its upper two
+// bits, where 3 is not a side. The value is ignored for a three-side split.
+static bool split_code_valid(int code)
+{
+    return (code & 0b11) == 3 || (code >> 2) != 3;
+}
+
 void TriangleSelector::deserialize(const TriangleSplittingData &data,
                                    bool                         needs_reset,
                                    EnforcerBlockerType          max_ebt,
@@ -1812,11 +1819,12 @@ void TriangleSelector::deserialize(const TriangleSplittingData &data,
 
     for (auto [triangle_id, ibit] : data.triangles_to_split) {
         assert(triangle_id < int(m_triangles.size()));
-        assert(ibit < int(data.bitstream.size()));
-        auto next_nibble = [&data, &ibit = ibit]() {
+        // Set when the bitstream runs out or holds an impossible split before this triangle's tree is complete.
+        bool corrupt = false;
+        auto next_nibble = [&data, &ibit = ibit, &corrupt]() {
             int n = 0;
-            for (int i = 0; i < 4; ++ i)
-                n |= data.bitstream[ibit ++] << i;
+            if (! data.read_nibble(ibit, n))
+                corrupt = true;
             return n;
         };
         // Decode a leaf state stored behind the "11" prefix: one nibble of (state-3) for states
@@ -1835,6 +1843,10 @@ void TriangleSelector::deserialize(const TriangleSplittingData &data,
             bool is_split = num_of_children != 0;
             // Only valid if not is_split.
             auto state = is_split ? EnforcerBlockerType::NONE : ((code & 0b1100) == 0b1100 ? decode_leaf_state() : EnforcerBlockerType(code >> 2));
+            if (is_split && ! split_code_valid(code))
+                corrupt = true;
+            if (corrupt)
+                break;
 
             // BBS
             if (state == to_delete_filament)
@@ -1849,7 +1861,7 @@ void TriangleSelector::deserialize(const TriangleSplittingData &data,
             }
 
             // Only valid if is_split.
-            int special_side = code >> 2;
+            int special_side = num_of_split_sides == 3 ? 0 : code >> 2;
 
             // Take care of the first iteration separately, so handling of the others is simpler.
             if (parents.empty()) {
@@ -1904,47 +1916,55 @@ void TriangleSelector::deserialize(const TriangleSplittingData &data,
             if (parents.empty())
                 break;
         }
+
+        if (corrupt) {
+            // Every split above allocated all of its children, so the partial tree unwinds cleanly.
+            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": malformed paint data, dropping paint of triangle " << triangle_id;
+            undivide_triangle(triangle_id);
+            m_triangles[triangle_id].set_state(EnforcerBlockerType::NONE);
+        }
     }
 }
 
-void TriangleSelector::TriangleSplittingData::update_used_states(const size_t bitstream_start_idx) {
-    assert(bitstream_start_idx < this->bitstream.size());
-    assert(!this->bitstream.empty() && this->bitstream.size() != bitstream_start_idx);
-    assert((this->bitstream.size() - bitstream_start_idx) % 4 == 0);
+bool TriangleSelector::TriangleSplittingData::update_used_states(const size_t bitstream_start_idx) {
+    int      ibit   = static_cast<int>(bitstream_start_idx);
+    uint64_t states = 0;
+    do {
+        // Walk one triangle's tree depth-first, counting the nodes still to be read; a split node adds its children.
+        for (int pending_nodes = 1; pending_nodes > 0; --pending_nodes) {
+            int code;
+            if (!this->read_nibble(ibit, code))
+                return false;
 
-    if (this->bitstream.empty() || this->bitstream.size() == bitstream_start_idx)
-        return;
+            if (const int num_of_split_sides = code & 0b11; num_of_split_sides != 0) {
+                if (!split_code_valid(code))
+                    return false;
+                pending_nodes += num_of_split_sides + 1;
+                continue;
+            }
 
-    size_t nibble_idx = bitstream_start_idx;
-
-    auto read_next_nibble = [&data_bitstream = std::as_const(this->bitstream), &nibble_idx]() -> uint8_t {
-        assert(nibble_idx + 3 < data_bitstream.size());
-        uint8_t code = 0;
-        for (size_t bit_idx = 0; bit_idx < 4; ++bit_idx)
-            code |= data_bitstream[nibble_idx++] << bit_idx;
-        return code;
-    };
-
-    while (nibble_idx < this->bitstream.size()) {
-        const uint8_t code = read_next_nibble();
-
-        if (const bool is_split = (code & 0b11) != 0; is_split)
-            continue;
-
-        uint8_t facet_state;
-        if ((code & 0b1100) == 0b1100) {
-            // Leaf behind the "11" prefix: one nibble of (state-3), or 0b1111 + (state-18).
-            const uint8_t nibble = read_next_nibble();
-            facet_state = nibble == 0b1111 ? uint8_t(read_next_nibble() + 18) : uint8_t(nibble + 3);
-        } else {
-            facet_state = code >> 2;
+            int facet_state = code >> 2;
+            if (facet_state == 0b11) {
+                // Leaf behind the "11" prefix: one nibble of (state-3), or 0b1111 + (state-18).
+                int nibble;
+                if (!this->read_nibble(ibit, nibble))
+                    return false;
+                facet_state = nibble + 3;
+                if (nibble == 0b1111) {
+                    if (!this->read_nibble(ibit, nibble))
+                        return false;
+                    facet_state = nibble + 18;
+                }
+            }
+            states |= uint64_t(1) << facet_state;
         }
-        assert(facet_state < this->used_states.size());
-        if (facet_state >= this->used_states.size())
-            continue;
+    } while (static_cast<size_t>(ibit) < this->bitstream.size());
 
-        this->used_states[facet_state] = true;
-    }
+    // The leaf encoding tops out at state 33, so every state fits the 64-bit mask.
+    for (size_t state_idx = 0; state_idx < std::min<size_t>(this->used_states.size(), 64); ++state_idx)
+        if (states & (uint64_t(1) << state_idx))
+            this->used_states[state_idx] = true;
+    return true;
 }
 
 // Lightweight variant of deserialization, which only tests whether a face of test_state exists.
@@ -1956,11 +1976,12 @@ bool TriangleSelector::has_facets(const TriangleSplittingData &data, const Enfor
 
     for (const TriangleBitStreamMapping &triangle_id_and_ibit : data.triangles_to_split) {
         int ibit = triangle_id_and_ibit.bitstream_start_idx;
-        assert(ibit < int(data.bitstream.size()));
-        auto next_nibble = [&data, &ibit = ibit]() {
+        // Stop reading a triangle whose stream is truncated.
+        bool truncated = false;
+        auto next_nibble = [&data, &ibit = ibit, &truncated]() {
             int n = 0;
-            for (int i = 0; i < 4; ++ i)
-                n |= data.bitstream[ibit ++] << i;
+            if (! data.read_nibble(ibit, n))
+                truncated = true;
             return n;
         };
         // < 0 -> negative of a number of children
@@ -1978,6 +1999,8 @@ bool TriangleSelector::has_facets(const TriangleSplittingData &data, const Enfor
         };
 
         int state = num_children_or_state();
+        if (truncated)
+            continue;
         if (state < 0) {
             // Root is split.
             parents_children.clear();
@@ -1985,6 +2008,8 @@ bool TriangleSelector::has_facets(const TriangleSplittingData &data, const Enfor
             do {
                 if (-- parents_children.back() >= 0) {
                     int state = num_children_or_state();
+                    if (truncated)
+                        break;
                     if (state < 0)
                         // Child is split.
                         parents_children.emplace_back(- state);

src/libslic3r/TriangleSelector.hpp

@@ -297,8 +297,20 @@ public:
             std::fill(used_states.begin(), used_states.end(), false);
         }
 
-        // Update used states based on the bitstream. It just iterated over the bitstream from the bitstream_start_idx till the end.
-        void update_used_states(size_t bitstream_start_idx);
+        // Update used states from the triangle trees stored between bitstream_start_idx and the end of the bitstream.
+        // Returns false and leaves used states untouched if a tree is truncated or malformed.
+        bool update_used_states(size_t bitstream_start_idx);
+
+        // Read the 4-bit code at bit index ibit (LSB first) and advance ibit past it.
+        // Returns false without advancing when fewer than 4 bits remain.
+        bool read_nibble(int &ibit, int &nibble) const {
+            if (ibit < 0 || static_cast<size_t>(ibit) + 4 > bitstream.size())
+                return false;
+            nibble = 0;
+            for (int i = 0; i < 4; ++i)
+                nibble |= static_cast<int>(bitstream[ibit++]) << i;
+            return true;
+        }
 
     private:
         friend class cereal::access;

src/slic3r/GUI/Plater.cpp

@@ -12800,6 +12800,8 @@ 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;
@@ -12846,18 +12848,8 @@ void Plater::priv::on_process_completed(SlicingProcessCompletedEvent &evt)
 
     {
         Slic3r::LifecycleEventContext ctx;
-        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.name = lifecycle_job_name;
+        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/UserManager.cpp

@@ -31,15 +31,14 @@ int UserManager::parse_json(std::string payload)
 {
     bool restored_json = false;
     json j;
+    json j_pre = json::parse(payload);
+    if (j_pre.empty()) {
+        return -1;
+    }
 
     //bind/unbind
 
     try {
-        json j_pre = json::parse(payload);
-        if (j_pre.empty()) {
-            return -1;
-        }
-
         if (j_pre.contains("bind")) {
             if (j_pre["bind"].contains("command")) {
 

src/slic3r/Utils/Duet.cpp

@@ -274,4 +274,13 @@ bool Duet::start_print(wxString &msg, const std::string &filename, ConnectionTyp
 	return res;
 }
 
+int Duet::get_err_code_from_body(const std::string &body) const
+{
+	pt::ptree root;
+	std::istringstream iss (body); // wrap returned json to istringstream
+	pt::read_json(iss, root);
+
+	return root.get<int>("err", 0);
+}
+
 }

src/slic3r/Utils/Duet.hpp

@@ -40,6 +40,7 @@ private:
 	ConnectionType connect(wxString &msg) const;
 	void disconnect(ConnectionType connectionType) const;
 	bool start_print(wxString &msg, const std::string &filename, ConnectionType connectionType, bool simulationMode) const;
+	int get_err_code_from_body(const std::string &body) const;
 };
 
 }

src/slic3r/Utils/ESP3D.cpp

@@ -146,6 +146,15 @@ bool ESP3D::start_print(wxString& msg, const std::string& filename) const
     return ret;
 }
 
+int ESP3D::get_err_code_from_body(const std::string& body) const
+{
+    pt::ptree          root;
+    std::istringstream iss(body); // wrap returned json to istringstream
+    pt::read_json(iss, root);
+
+    return root.get<int>("err", 0);
+}
+
 // ESP3D only accepts 8.3 filenames else it crashes marlin and other undefined behaviour
 std::string ESP3D::get_short_name(const std::string& filename) const
 {

src/slic3r/Utils/ESP3D.hpp

@@ -33,6 +33,7 @@ private:
     std::string m_console_port;
 
     bool        start_print(wxString& msg, const std::string& filename) const;
+    int         get_err_code_from_body(const std::string& body) const;
     std::string get_short_name(const std::string& filename) const;
     std::string format_command(const std::string& path, const std::string& arg, const std::string& val) const;
 };

src/slic3r/Utils/Flashforge.cpp

@@ -510,22 +510,12 @@ bool Flashforge::fetch_material_slots(std::vector<FlashforgeMaterialSlot>& slots
     if (!request_local_api_json("detail", json{{"serialNumber", m_serial_number}, {"checkCode", m_check_code}}.dump(), body, msg))
         return false;
 
-    if (!parse_material_slots(body, slots, supports_material_station)) {
+    const auto parsed = json::parse(body, nullptr, false, true);
+    if (parsed.is_discarded()) {
         msg = _(L("Flashforge returned an invalid JSON response."));
         return false;
     }
 
-    return true;
-}
-
-bool Flashforge::parse_material_slots(const std::string& body, std::vector<FlashforgeMaterialSlot>& slots, bool* supports_material_station)
-{
-    slots.clear();
-
-    const auto parsed = json::parse(body, nullptr, false, true);
-    if (parsed.is_discarded())
-        return false;
-
     const auto& detail = parsed.contains("detail") ? parsed["detail"] : parsed;
     const auto& station = detail.contains("matlStationInfo") ? detail["matlStationInfo"] :
                           detail.contains("MatlStationInfo") ? detail["MatlStationInfo"] : json();
@@ -552,21 +542,12 @@ bool Flashforge::parse_material_slots(const std::string& body, std::vector<Flash
     if (supports_material_station != nullptr)
         *supports_material_station = reports_material_station;
 
-    // Fields are read leniently: firmware may send numbers as strings or flags as numbers.
     for (const auto& slot : slot_infos) {
-        if (!slot.is_object())
-            continue;
         FlashforgeMaterialSlot info;
-        info.slot_id = static_cast<int>(slots.size()) + 1;
-        if (const auto it = slot.find("slotId"); it != slot.end())
-            try_parse_json_int(*it, info.slot_id);
-        int has_filament = 0;
-        if (const auto it = slot.find("hasFilament"); it != slot.end() && try_parse_json_int(*it, has_filament))
-            info.has_filament = has_filament != 0;
-        if (const auto it = slot.find("materialName"); it != slot.end() && it->is_string())
-            info.material_name = it->get<std::string>();
-        if (const auto it = slot.find("materialColor"); it != slot.end() && it->is_string())
-            info.material_color = it->get<std::string>();
+        info.slot_id        = slot.value("slotId", static_cast<int>(slots.size()) + 1);
+        info.has_filament   = slot.value("hasFilament", false);
+        info.material_name  = slot.value("materialName", std::string());
+        info.material_color = slot.value("materialColor", std::string());
         slots.emplace_back(std::move(info));
     }
 
@@ -689,4 +670,13 @@ std::string Flashforge::extract_host_name() const
     return out;
 }
 
+int Flashforge::get_err_code_from_body(const std::string& body) const
+{
+    pt::ptree          root;
+    std::istringstream iss(body); // wrap returned json to istringstream
+    pt::read_json(iss, root);
+
+    return root.get<int>("err", 0);
+}
+
 } // namespace Slic3r

src/slic3r/Utils/Flashforge.hpp

@@ -45,8 +45,6 @@ public:
     PrintHostPostUploadActions get_post_upload_actions() const override { return PrintHostPostUploadAction::StartPrint; }
     std::string                get_host() const override { return m_host; }
     bool                       fetch_material_slots(std::vector<FlashforgeMaterialSlot>& slots, bool* supports_material_station, wxString& msg) const;
-    // Parses a local API "detail" reply. Returns false when the body is not valid JSON.
-    static bool                parse_material_slots(const std::string& body, std::vector<FlashforgeMaterialSlot>& slots, bool* supports_material_station);
     static bool                discover_printers(std::vector<FlashforgeDiscoveredPrinter>& printers, wxString& msg, int timeout_ms = 10000, int idle_timeout_ms = 1500, int max_retries = 3);
 
 private:
@@ -70,6 +68,7 @@ private:
     bool request_local_api_json(const std::string& path, const std::string& body, std::string& response_body, wxString& error_msg) const;
     std::string make_http_url(const std::string& path) const;
     std::string extract_host_name() const;
+    int  get_err_code_from_body(const std::string &body) const;
     bool connect(wxString& msg) const;
     bool start_print(wxString& msg, const std::string& filename) const;
 };

src/slic3r/Utils/MKS.cpp

@@ -141,4 +141,13 @@ bool MKS::start_print(wxString& msg, const std::string& filename) const
 	return ret;
 }
 
+int MKS::get_err_code_from_body(const std::string& body) const
+{
+	pt::ptree root;
+	std::istringstream iss(body); // wrap returned json to istringstream
+	pt::read_json(iss, root);
+
+	return root.get<int>("err", 0);
+}
+
 } // Slic3r

src/slic3r/Utils/MKS.hpp

@@ -34,6 +34,7 @@ private:
 
 	std::string get_upload_url(const std::string& filename) const;
 	bool start_print(wxString& msg, const std::string& filename) const;
+	int get_err_code_from_body(const std::string& body) const;
 };
 
 }

src/slic3r/Utils/PrintHost.cpp

@@ -3,13 +3,9 @@
 #include <vector>
 #include <thread>
 #include <exception>
-#include <sstream>
 #include <boost/optional.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/filesystem.hpp>
-#include <nlohmann/json.hpp>
-#include <boost/property_tree/ptree.hpp>
-#include <boost/property_tree/json_parser.hpp>
 
 #include <wx/string.h>
 #include <wx/app.h>
@@ -119,81 +115,10 @@ 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
-
-int PrintHost::get_err_code_from_body(const std::string &body)
-{
-    boost::property_tree::ptree root;
-    std::istringstream iss(body);
-    try {
-        boost::property_tree::read_json(iss, root);
-    } catch (const std::exception &ex) {
-        BOOST_LOG_TRIVIAL(error) << "PrintHost: response is not valid JSON: " << ex.what();
-        return -1;
-    }
-
-    return root.get<int>("err", 0);
-}
-
 wxString PrintHost::format_error(const std::string &body, const std::string &error, unsigned status) const
 {
     if (status != 0) {
-        const std::string reason = moonraker_error_reason(body);
-        auto wxbody = wxString::FromUTF8(reason.empty() ? body : reason);
+        auto wxbody = wxString::FromUTF8(body.data());
         return wxString::Format("HTTP %u: %s", status, wxbody);
     } else {
         if (error.find("curl:Timeout was reached") != std::string::npos) {
@@ -432,10 +357,12 @@ void PrintHostJobQueue::priv::remove_source()
     source_to_remove.clear();
 }
 
-bool PrintHostJobQueue::upload_job(PrintHostJob &job, PrintHost::ProgressFn progress_fn, PrintHost::ErrorFn error_fn, PrintHost::InfoFn info_fn)
+void PrintHostJobQueue::priv::perform_job(PrintHostJob the_job)
 {
+    emit_progress(0);   // Indicate the upload is starting
+
     // Captured before upload_data is moved into upload() below.
-    const std::string upload_filename = job.upload_data.source_path.filename().string();
+    const std::string upload_filename = the_job.upload_data.source_path.filename().string();
 
     {
         LifecycleEventContext ctx;
@@ -444,37 +371,19 @@ bool PrintHostJobQueue::upload_job(PrintHostJob &job, PrintHost::ProgressFn prog
         fire_lifecycle_event(LifecycleEvent::UploadStarted, ctx);
     }
 
-    bool success = false;
-    std::string error;
-    // A throwing upload must not stop the worker, or later jobs would stay queued forever.
-    try {
-        success = job.printhost->upload(std::move(job.upload_data), std::move(progress_fn), error_fn, std::move(info_fn));
-    } catch (const std::exception &e) {
-        error = e.what();
-        error_fn(error);
-    }
+    bool success = the_job.printhost->upload(std::move(the_job.upload_data),
+        [this](Http::Progress progress, bool &cancel)   { this->progress_fn(std::move(progress), cancel); },
+        [this](wxString error)                          { this->error_fn(std::move(error)); },
+        [this](wxString tag, wxString host)             { this->info_fn(std::move(tag), std::move(host)); }
+    );
 
     {
         LifecycleEventContext ctx;
         ctx.name  = upload_filename;
         ctx.code  = success ? LifecycleEvtCode::Ok : LifecycleEvtCode::Error;
-        ctx.msg   = error;
         fire_lifecycle_event(LifecycleEvent::UploadFinished, ctx);
     }
 
-    return success;
-}
-
-void PrintHostJobQueue::priv::perform_job(PrintHostJob the_job)
-{
-    emit_progress(0);   // Indicate the upload is starting
-
-    bool success = PrintHostJobQueue::upload_job(the_job,
-        [this](Http::Progress progress, bool &cancel)   { this->progress_fn(std::move(progress), cancel); },
-        [this](wxString error)                          { this->error_fn(std::move(error)); },
-        [this](wxString tag, wxString host)             { this->info_fn(std::move(tag), std::move(host)); }
-    );
-
     if (success) {
         emit_progress(100);
         if (the_job.switch_to_device_tab) {

src/slic3r/Utils/PrintHost.hpp

@@ -87,8 +87,6 @@ public:
 
     static PrintHost* get_print_host(DynamicPrintConfig *config);
     static std::string get_print_host_webui(DynamicPrintConfig *config);
-    // Reads the "err" field of a JSON reply, 0 when absent. Returns -1 when the body is not valid JSON.
-    static int get_err_code_from_body(const std::string &body);
 
     //Support for cloud webui login
     virtual bool is_cloud() const { return false; }
@@ -152,10 +150,6 @@ public:
     void enqueue(PrintHostJob job);
     void cancel(size_t id);
 
-    // Uploads the job, firing UploadStarted and a matching UploadFinished. An exception thrown by
-    // the upload is reported through error_fn and makes the upload fail.
-    static bool upload_job(PrintHostJob &job, PrintHost::ProgressFn progress_fn, PrintHost::ErrorFn error_fn, PrintHost::InfoFn info_fn);
-
 private:
     struct priv;
     std::shared_ptr<priv> p;

src/slic3r/Utils/UltiMaker.cpp

@@ -654,4 +654,13 @@ bool UltiMaker::start_print(wxString &msg, const std::string &filename, Connecti
 	return res;
 }
 
+int UltiMaker::get_err_code_from_body(const std::string &body) const
+{
+	pt::ptree root;
+	std::istringstream iss (body); // wrap returned json to istringstream
+	pt::read_json(iss, root);
+
+	return root.get<int>("err", 0);
+}
+
 }

src/slic3r/Utils/UltiMaker.hpp

@@ -64,6 +64,7 @@ private:
 	void set_auth(Http& http) const;
 	void disconnect(ConnectionType connectionType) const;
 	bool start_print(wxString &msg, const std::string &filename, ConnectionType connectionType) const;
+	int get_err_code_from_body(const std::string &body) const;
 };
 
 }

tests/fff_print/test_print.cpp

@@ -15,9 +15,6 @@
 #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"
@@ -25,10 +22,7 @@
 #include <algorithm>
 #include <fstream>
 #include <iterator>
-#include <memory>
 #include <string_view>
-#include <utility>
-#include <vector>
 
 using namespace Slic3r;
 using namespace Slic3r::Test;
@@ -230,88 +224,8 @@ 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/test_3mf.cpp

@@ -19,6 +19,7 @@
 #include <boost/filesystem/operations.hpp>
 #include <boost/algorithm/string/predicate.hpp>
 #include <algorithm>
+#include <functional>
 
 #include <catch2/catch_tostring.hpp>
 #include <Eigen/Core>
@@ -184,16 +185,13 @@ static bool read_cad_recipe_entry(const std::string& path, std::string& out,
     return found;
 }
 
-// Rewrites the archive at `path` with the recipe entry back under the name it had before the
-// rename, which is what every project saved by an earlier build looks like on disk. Generated
-// rather than checked in because a whole project archive is not frozen evidence the way a bare
-// recipe blob is -- it has to be whatever today's exporter writes, with only the name aged.
-// miniz cannot rename in place and open_zip_writer truncates, so the entries are held across
-// the switch.
-static void rename_cad_recipe_entry_to_legacy(const std::string& path)
+// Rewrites the archive at `path`, letting `edit` change the name or data of each entry; returns
+// whether `edit` reported a change for any of them. miniz cannot edit in place and
+// open_zip_writer truncates, so the entries are held across the switch.
+static bool rewrite_3mf_entries(const std::string& path, const std::function<bool(std::string& name, std::string& data)>& edit)
 {
     std::vector<std::pair<std::string, std::string>> entries;
-    bool renamed = false;
+    bool changed = false;
     {
         mz_zip_archive zip;
         mz_zip_zero_struct(&zip);
@@ -208,22 +206,140 @@ static void rename_cad_recipe_entry_to_legacy(const std::string& path)
             std::string data((size_t) st.m_uncomp_size, '\0');
             if (st.m_uncomp_size > 0)
                 REQUIRE(mz_zip_reader_extract_to_mem(&zip, i, data.data(), data.size(), 0));
-            if (boost::algorithm::iequals(name, CAD_RECIPE_ENTRY)) {
-                name    = LEGACY_CAD_RECIPE_ENTRY;
-                renamed = true;
-            }
+            changed |= edit(name, data);
             entries.emplace_back(std::move(name), std::move(data));
         }
         close_zip_reader(&zip);
     }
-    // Without this the scenario would degrade silently into re-testing the new name if the
-    // exporter's constant ever moved again: every load below would still pass.
-    REQUIRE(renamed);
 
     Zipper out(path);
     for (const auto& e : entries)
         out.add_entry(e.first, e.second.data(), e.second.size());
     out.finalize();
+    return changed;
+}
+
+// Rewrites the archive at `path` with the recipe entry back under the name it had before the
+// rename, which is what every project saved by an earlier build looks like on disk. Generated
+// rather than checked in because a whole project archive is not frozen evidence the way a bare
+// recipe blob is -- it has to be whatever today's exporter writes, with only the name aged.
+static void rename_cad_recipe_entry_to_legacy(const std::string& path)
+{
+    const bool renamed = rewrite_3mf_entries(path, [](std::string& name, std::string&) {
+        if (!boost::algorithm::iequals(name, CAD_RECIPE_ENTRY))
+            return false;
+        name = LEGACY_CAD_RECIPE_ENTRY;
+        return true;
+    });
+    // Without this the scenario would degrade silently into re-testing the new name if the
+    // exporter's constant ever moved again: every load below would still pass.
+    REQUIRE(renamed);
+}
+
+// Replaces the first occurrence of `from` in any entry whose name ends with `suffix`.
+static bool replace_in_3mf_entry(const std::string& path, const std::string& suffix, const std::string& from, const std::string& to)
+{
+    bool replaced = false;
+    rewrite_3mf_entries(path, [&](std::string& name, std::string& data) {
+        if (replaced || !boost::algorithm::ends_with(name, suffix))
+            return false;
+        if (const size_t pos = data.find(from); pos != std::string::npos) {
+            data.replace(pos, from.size(), to);
+            replaced = true;
+        }
+        return replaced;
+    });
+    return replaced;
+}
+
+// Stores a one-plate project holding a cube whose first two facets are painted Extruder2 and
+// Extruder3, which the exporter writes as paint_color="8" and paint_color="0C".
+static void store_painted_cube(const std::string& path)
+{
+    Model        model;
+    ModelObject* object = model.add_object();
+    ModelVolume* volume = object->add_volume(make_cube(10., 10., 10.));
+    object->add_instance();
+    {
+        TriangleSelector selector(volume->mesh());
+        selector.set_facet(0, EnforcerBlockerType::Extruder2);
+        selector.set_facet(1, EnforcerBlockerType::Extruder3);
+        REQUIRE(volume->mmu_segmentation_facets.set(selector));
+    }
+    ScopedTemporaryDir backup_dir("orca_paint_src");
+    model.set_backup_path(backup_dir.string());
+
+    DynamicPrintConfig cfg;
+    PlateData          plate;
+    plate.plate_index = 0;
+    StoreParams sp;
+    sp.path     = path.c_str();
+    sp.model    = &model;
+    sp.config   = &cfg;
+    sp.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
+    sp.plate_data_list.push_back(&plate);
+    REQUIRE(store_bbs_3mf(sp));
+}
+
+// Loads `path` through the BBS importer into `model`, releasing the plates it returns. The
+// importer stages metadata through `backup_dir`, which has to outlive the model.
+static bool load_project(const std::string& path, Model& model, const ScopedTemporaryDir& backup_dir)
+{
+    model.set_backup_path(backup_dir.string());
+    DynamicPrintConfig        config;
+    ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Enable };
+    PlateDataPtrs             plates;
+    std::vector<Preset*>      project_presets;
+    bool   is_bbl_3mf = false, is_orca_3mf = false;
+    Semver file_version;
+    const bool loaded = load_bbs_3mf(path.c_str(), &config, &ctxt, &model, &plates, &project_presets, &is_bbl_3mf,
+                                     &is_orca_3mf, &file_version, nullptr, LoadStrategy::LoadModel | LoadStrategy::LoadConfig);
+    release_PlateData_list(plates);
+    return loaded;
+}
+
+TEST_CASE("A project with a plate id below 1 fails to load", "[3mf][Regression]")
+{
+    const int plate_id = GENERATE(0, -1);
+    INFO("plater_id " << plate_id);
+
+    ScopedTemporaryFile temp(".3mf");
+    store_painted_cube(temp.string());
+    {
+        ScopedTemporaryDir backup_dir("orca_plate_dst");
+        Model              model;
+        REQUIRE(load_project(temp.string(), model, backup_dir));
+    }
+
+    REQUIRE(replace_in_3mf_entry(temp.string(), "model_settings.config", "key=\"plater_id\" value=\"1\"",
+                                 "key=\"plater_id\" value=\"" + std::to_string(plate_id) + "\""));
+    ScopedTemporaryDir backup_dir("orca_plate_dst");
+    Model              model;
+    bool               loaded = true;
+    REQUIRE_NOTHROW(loaded = load_project(temp.string(), model, backup_dir));
+    REQUIRE_FALSE(loaded);
+}
+
+TEST_CASE("A project with malformed paint data loads without the damaged facet", "[3mf][Regression]")
+{
+    ScopedTemporaryFile temp(".3mf");
+    store_painted_cube(temp.string());
+    // Split codes with no children behind them: the stream runs out mid-tree.
+    REQUIRE(replace_in_3mf_entry(temp.string(), ".model", "paint_color=\"8\"", "paint_color=\"FFFFFFFFFFFFFFFF3\""));
+
+    ScopedTemporaryDir backup_dir("orca_paint_dst");
+    Model              model;
+    REQUIRE(load_project(temp.string(), model, backup_dir));
+    REQUIRE(model.objects.size() == 1);
+    const ModelVolume& volume = *model.objects.front()->volumes.front();
+    const auto&        data   = volume.mmu_segmentation_facets.get_data();
+    REQUIRE_FALSE(data.used_states[size_t(EnforcerBlockerType::Extruder2)]);
+    REQUIRE(data.used_states[size_t(EnforcerBlockerType::Extruder3)]);
+
+    TriangleSelector selector(volume.mesh());
+    REQUIRE_NOTHROW(selector.deserialize(data));
+    REQUIRE(selector.num_facets(EnforcerBlockerType::Extruder2) == 0);
+    REQUIRE(selector.num_facets(EnforcerBlockerType::Extruder3) == 1);
 }
 
 // The recipe lives only in the BBS-native backend, because that is the only one that runs:

tests/libslic3r/test_triangle_selector.cpp

@@ -3,6 +3,8 @@
 #include "libslic3r/TriangleSelector.hpp"
 #include "libslic3r/TriangleMesh.hpp"
 
+#include <algorithm>
+
 using namespace Slic3r;
 
 // A sphere gives well over ExtruderMax original facets, so every extruder state can be assigned
@@ -123,3 +125,77 @@ TEST_CASE("Extruder states match the CONST_FILAMENTS hex encoding", "[TriangleSe
     INFO("Hex " << c.hex << " -> extruder " << c.state);
     REQUIRE(TriangleSelector::has_facets(data, EnforcerBlockerType(c.state)));
 }
+
+// Pack 4-bit codes into a bitstream, least significant bit first, in the order the decoder reads them.
+static std::vector<bool> pack_nibbles(const std::vector<int> &nibbles)
+{
+    std::vector<bool> bitstream;
+    for (const int nibble : nibbles)
+        for (int bit = 0; bit < 4; ++bit)
+            bitstream.push_back((nibble >> bit) & 1);
+    return bitstream;
+}
+
+TEST_CASE("A valid paint stream with nested splits round-trips bit for bit", "[TriangleSelector]")
+{
+    const TriangleMesh mesh = test_mesh();
+
+    TriangleSelector::TriangleSplittingData data;
+    data.triangles_to_split.emplace_back(0, 0);
+    // A three-side split whose children, in stream order, are: a one-side split (side 2) into two
+    // leaves, a two-side split (side 1) into leaves of states 20, 0 and 8, then two plain leaves.
+    const std::vector<int> triangle_0 = {0b0011,
+                                         0b1001, 0b1000, 0b0100,
+                                         0b0110, 0b1100, 0b1111, 20 - 18, 0b0000, 0b1100, 8 - 3,
+                                         0b1000,
+                                         0b0100};
+    data.bitstream = pack_nibbles(triangle_0);
+    data.triangles_to_split.emplace_back(5, int(data.bitstream.size()));
+    const std::vector<bool> triangle_5 = pack_nibbles({0b1100, 3 - 3});
+    data.bitstream.insert(data.bitstream.end(), triangle_5.begin(), triangle_5.end());
+    data.reset_used_states();
+    REQUIRE(data.update_used_states(0));
+
+    TriangleSelector restored(mesh);
+    restored.deserialize(data);
+
+    REQUIRE(restored.num_facets(EnforcerBlockerType::Extruder20) == 1);
+    REQUIRE(restored.num_facets(EnforcerBlockerType::Extruder3) == 1);
+    REQUIRE(restored.serialize() == data);
+}
+
+TEST_CASE("A truncated or malformed paint stream drops only the damaged triangle", "[TriangleSelector][Regression]")
+{
+    struct Case { const char *name; std::vector<int> nibbles; };
+    const auto c = GENERATE(values<Case>({
+        {"three-side split missing two children", {0b0011, 0b1000, 0b1000}},
+        {"leaf missing its state nibble",         {0b1100}},
+        {"leaf missing its second state nibble",  {0b1100, 0b1111}},
+        {"splits nested past the end",            {0b0011, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF,
+                                                    0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF}},
+        {"one-side split of the nonexistent side 3", {0b1101, 0b1000, 0b1000}},
+    }));
+    INFO(c.name);
+
+    const TriangleMesh mesh = test_mesh();
+    TriangleSelector   intact(mesh);
+    intact.set_facet(0, EnforcerBlockerType::Extruder2);
+
+    // Triangle 0 stays intact, triangle 1 carries the damaged stream.
+    TriangleSelector::TriangleSplittingData data = intact.serialize();
+    data.triangles_to_split.emplace_back(1, int(data.bitstream.size()));
+    const std::vector<bool> damaged = pack_nibbles(c.nibbles);
+    data.bitstream.insert(data.bitstream.end(), damaged.begin(), damaged.end());
+
+    TriangleSelector restored(mesh);
+    REQUIRE_NOTHROW(restored.deserialize(data));
+    // Triangle 1 unwinds completely, so the selector holds exactly the intact paint.
+    REQUIRE(restored.serialize() == intact.serialize());
+
+    REQUIRE_NOTHROW(TriangleSelector::has_facets(data, EnforcerBlockerType::Extruder3));
+
+    TriangleSelector::TriangleSplittingData recomputed = data;
+    recomputed.reset_used_states();
+    REQUIRE_FALSE(recomputed.update_used_states(0));
+    REQUIRE(std::none_of(recomputed.used_states.begin(), recomputed.used_states.end(), [](bool used) { return used; }));
+}

tests/slic3rutils/CMakeLists.txt

@@ -18,14 +18,12 @@ 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
     test_plugin_cloud_metadata.cpp
     test_plugin_audit.cpp
     test_shortcuts.cpp
-    test_user_manager.cpp
     ../fff_print/test_helpers.cpp
     )
 

tests/slic3rutils/test_printhost.cpp

@@ -1,374 +0,0 @@
-#include <catch2/catch_all.hpp>
-
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-#include <nlohmann/json.hpp>
-
-#include "libslic3r/LifecycleEvents.hpp"
-#include "slic3r/Utils/PrintHost.hpp"
-#include "slic3r/Utils/Flashforge.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 {}; }
-};
-
-class ThrowingPrintHost : public TestPrintHost
-{
-public:
-    bool upload(PrintHostUpload, ProgressFn, ErrorFn, InfoFn) const override { throw std::runtime_error("reply could not be read"); }
-};
-
-struct UploadEvents
-{
-    std::vector<LifecycleEvent>   events;
-    std::vector<LifecycleEvtCode> codes;
-    std::vector<std::string>      errors;
-    bool                          uploaded{false};
-
-    explicit UploadEvents(std::unique_ptr<PrintHost> host)
-    {
-        set_lifecycle_hook_fn([this](LifecycleEvent event, const LifecycleEventContext& ctx) {
-            events.push_back(event);
-            codes.push_back(ctx.code);
-        });
-
-        PrintHostJob job;
-        job.printhost               = std::move(host);
-        job.upload_data.source_path = "plate.gcode";
-        try {
-            uploaded = PrintHostJobQueue::upload_job(job, [](Http::Progress, bool&) {},
-                                                     [this](wxString error) { errors.push_back(error.ToStdString()); },
-                                                     [](wxString, wxString) {});
-        } catch (...) {
-            set_lifecycle_hook_fn(nullptr);
-            throw;
-        }
-        set_lifecycle_hook_fn(nullptr);
-    }
-};
-
-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";
-
-// Replies a print host can send instead of JSON: a proxy or login page, nothing, a cut-off body.
-const std::vector<std::string> non_json_replies = {
-    "<html><body>proxy login required</body></html>",
-    "",
-    "{\"err\":",
-    "{\"detail\":{\"matlStationInfo\":{\"slotInfos\":[{\"slotId\":1,",
-};
-
-} // 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");
-    }
-}
-
-TEST_CASE("Print host error code is read from a JSON reply", "[PrintHost]")
-{
-    CHECK(PrintHost::get_err_code_from_body(R"({"err":0})") == 0);
-    CHECK(PrintHost::get_err_code_from_body(R"({"err":2})") == 2);
-    CHECK(PrintHost::get_err_code_from_body(R"({"status":"ok"})") == 0);
-}
-
-TEST_CASE("Print host error code reports a reply that is not JSON as an error", "[PrintHost]")
-{
-    const std::string body = GENERATE(from_range(non_json_replies));
-    int err = 0;
-    REQUIRE_NOTHROW(err = PrintHost::get_err_code_from_body(body));
-    CHECK(err != 0);
-}
-
-TEST_CASE("Print host error code tolerates a wrongly typed err field", "[PrintHost]")
-{
-    const std::string body = GENERATE(as<std::string>{}, R"({"err":"busy"})", R"({"err":{"code":1}})", R"([1,2])");
-    CHECK_NOTHROW(PrintHost::get_err_code_from_body(body));
-}
-
-TEST_CASE("Flashforge material slots are read from a well-formed reply", "[PrintHost][Flashforge]")
-{
-    const std::string body = R"({"code":0,"detail":{"hasMatlStation":true,"matlStationInfo":{"slotCnt":2,"slotInfos":[
-        {"slotId":1,"hasFilament":true,"materialName":"PLA","materialColor":"#FFFFFF"},
-        {"slotId":2,"hasFilament":false,"materialName":"","materialColor":""}]}}})";
-
-    std::vector<FlashforgeMaterialSlot> slots;
-    bool supports_station = false;
-    REQUIRE(Flashforge::parse_material_slots(body, slots, &supports_station));
-    CHECK(supports_station);
-    REQUIRE(slots.size() == 2);
-    CHECK(slots[0].slot_id == 1);
-    CHECK(slots[0].has_filament);
-    CHECK(slots[0].material_name == "PLA");
-    CHECK(slots[0].material_color == "#FFFFFF");
-    CHECK(slots[1].slot_id == 2);
-    CHECK_FALSE(slots[1].has_filament);
-}
-
-TEST_CASE("Flashforge material slots accept numbers as strings and flags as numbers", "[PrintHost][Flashforge]")
-{
-    const std::string body = R"({"detail":{"matlStationInfo":{"slotInfos":[
-        {"slotId":"3","hasFilament":1,"materialName":null,"materialColor":7}]}}})";
-
-    std::vector<FlashforgeMaterialSlot> slots;
-    REQUIRE_NOTHROW(Flashforge::parse_material_slots(body, slots, nullptr));
-    REQUIRE(slots.size() == 1);
-    CHECK(slots[0].slot_id == 3);
-    CHECK(slots[0].has_filament);
-    CHECK(slots[0].material_name.empty());
-    CHECK(slots[0].material_color.empty());
-}
-
-TEST_CASE("Flashforge material slots skip entries that are not objects", "[PrintHost][Flashforge]")
-{
-    const std::string body = R"({"detail":{"matlStationInfo":{"slotInfos":[5,"slot",null,[],
-        {"slotId":4,"hasFilament":true,"materialName":"PETG"}]}}})";
-
-    std::vector<FlashforgeMaterialSlot> slots;
-    REQUIRE_NOTHROW(Flashforge::parse_material_slots(body, slots, nullptr));
-    REQUIRE(slots.size() == 1);
-    CHECK(slots[0].slot_id == 4);
-    CHECK(slots[0].material_name == "PETG");
-}
-
-TEST_CASE("Flashforge material slots tolerate slot info that is not a list", "[PrintHost][Flashforge]")
-{
-    const std::string body = GENERATE(as<std::string>{},
-                                      R"({"detail":{"matlStationInfo":{"slotInfos":5}}})",
-                                      R"({"detail":{"matlStationInfo":{"slotInfos":"none"}}})",
-                                      R"({"detail":{"matlStationInfo":7}})",
-                                      R"({"detail":"offline"})");
-
-    std::vector<FlashforgeMaterialSlot> slots;
-    bool ok = false;
-    REQUIRE_NOTHROW(ok = Flashforge::parse_material_slots(body, slots, nullptr));
-    CHECK(ok);
-    CHECK(slots.empty());
-}
-
-TEST_CASE("Flashforge material slots reject a reply that is not JSON", "[PrintHost][Flashforge]")
-{
-    const std::string body = GENERATE(from_range(non_json_replies));
-    std::vector<FlashforgeMaterialSlot> slots;
-    bool ok = true;
-    REQUIRE_NOTHROW(ok = Flashforge::parse_material_slots(body, slots, nullptr));
-    CHECK_FALSE(ok);
-    CHECK(slots.empty());
-}
-
-TEST_CASE("An upload that throws still finishes with an error", "[PrintHost][LifecycleEvents]")
-{
-    UploadEvents run(std::make_unique<ThrowingPrintHost>());
-
-    CHECK_FALSE(run.uploaded);
-    CHECK(run.errors == std::vector<std::string>{"reply could not be read"});
-    CHECK(run.events == std::vector<LifecycleEvent>{LifecycleEvent::UploadStarted, LifecycleEvent::UploadFinished});
-    CHECK(run.codes == std::vector<LifecycleEvtCode>{LifecycleEvtCode::Ok, LifecycleEvtCode::Error});
-}
-
-TEST_CASE("A successful upload finishes without an error", "[PrintHost][LifecycleEvents]")
-{
-    UploadEvents run(std::make_unique<TestPrintHost>());
-
-    CHECK(run.uploaded);
-    CHECK(run.errors.empty());
-    CHECK(run.events == std::vector<LifecycleEvent>{LifecycleEvent::UploadStarted, LifecycleEvent::UploadFinished});
-    CHECK(run.codes == std::vector<LifecycleEvtCode>{LifecycleEvtCode::Ok, LifecycleEvtCode::Ok});
-}

tests/slic3rutils/test_user_manager.cpp

@@ -1,23 +0,0 @@
-#include <catch2/catch_all.hpp>
-
-#include <string>
-
-#include "slic3r/GUI/UserManager.hpp"
-
-using namespace Slic3r;
-
-TEST_CASE("User message that is not JSON is rejected without throwing", "[UserManager]")
-{
-    const std::string payload = GENERATE(as<std::string>{}, "not json", "", "<html></html>", "{\"bind\":");
-    UserManager manager;
-    int result = 0;
-    REQUIRE_NOTHROW(result = manager.parse_json(payload));
-    CHECK(result == -1);
-}
-
-TEST_CASE("User message without a successful bind is ignored", "[UserManager]")
-{
-    const std::string payload = GENERATE(as<std::string>{}, "{}", R"({"bind":{"command":"unbind"}})", R"({"bind":"bind"})", "[1]");
-    UserManager manager;
-    CHECK(manager.parse_json(payload) == -1);
-}