Remove Duplicate Includes and the Dead GCodeSender Sources

46 files include the same header twice at file scope, outside any #if,
66 times in all:
Model.cpp included Model.hpp twice, Utils.hpp <algorithm> and
<string_view> twice, seven GUI headers <wx/dataview.h> and
<wx/artprov.h> twice. The second include of each is removed.

GCodeSender.cpp and GCodeSender.hpp have been commented out of
libslic3r/CMakeLists.txt since 2022 and their only two includes are
commented out as well. Both files go, with the commented lines, and
the CMake entry for SLA/SupportTreeIGL.cpp, a file that no longer
exists.

resources/web/guide/21/common.js

@@ -311,7 +311,7 @@ function CreatePrinterBlock(OneModel)
 
 	return	'<div class="PrinterBlock" onClick="ChooseModel(\''+vendor+'\',\''+OneModel['model']+'\')">'+
 			'	<div class="PImg">'+
-			'		<img class="ModelThumbnail" src="' + OneModel['cover'] + '" onerror="this.onerror=null;this.src=\'../img/printer-dummy.png\';"/>'+
+			'		<img class="ModelThumbnail" src="' + OneModel['cover'] + '" />'+
 			'	</div>'+
 			'	<div class="PrinterInfoMark">?</div>'+
 			'	<div class="PrinterInfo">'+

src/libslic3r/CAD/CadDocument.cpp

@@ -83,7 +83,6 @@
 #include <cmath>
 #include <cctype>
 #include <cstdio>
-#include <functional>
 #include <gp_XY.hxx>
 #include <initializer_list>
 #include <math.h>

src/libslic3r/CMakeLists.txt

@@ -261,8 +261,6 @@ set(lisbslic3r_sources
     GCode/PreciseSeam.cpp
     GCode/PreciseSeam.hpp
     GCode/PreciseSeamInternal.hpp
-    #GCodeSender.cpp
-    #GCodeSender.hpp
     GCode/SmallAreaInfillFlowCompensator.cpp
     GCode/SmallAreaInfillFlowCompensator.hpp
     GCode/SpiralVase.cpp
@@ -447,7 +445,6 @@ set(lisbslic3r_sources
     SLA/SupportTreeBuildsteps.hpp
     SLA/SupportTree.cpp
     SLA/SupportTree.hpp
-    #SLA/SupportTreeIGL.cpp
     SLA/SupportTreeMesher.cpp
     SLA/SupportTreeMesher.hpp
     SlicesToTriangleMesh.cpp

src/libslic3r/CutSurface.cpp

@@ -2589,7 +2589,6 @@ void priv::create_face_types(FaceTypeMap           &map,
 }
 
 #include <CGAL/Polygon_mesh_processing/clip.h>
-#include <CGAL/Polygon_mesh_processing/corefinement.h>
 bool priv::clip_cut(SurfacePatch &cut, CutMesh clipper)
 {
     CutMesh& tm = cut.mesh; 

src/libslic3r/Emboss.cpp

@@ -15,7 +15,6 @@
 #include "Emboss.hpp"
 #include <optional>
 #include <stdio.h>
-#include <numeric>
 #include <cstdlib>
 #include <boost/nowide/convert.hpp>
 #include <boost/log/trivial.hpp>

src/libslic3r/Format/STEP.cpp

@@ -55,7 +55,6 @@
 #include "TDataStd_Name.hxx"
 #include "BRepBuilderAPI_Transform.hxx"
 #include "TopExp_Explorer.hxx"
-#include "TopExp_Explorer.hxx"
 #include "BRep_Tool.hxx"
 #include "BRepTools.hxx"
 #include <IMeshTools_Parameters.hxx>

src/libslic3r/GCode.cpp

@@ -43,7 +43,6 @@
 #include "Print.hpp"
 #include "Utils.hpp"
 #include "ClipperUtils.hpp"
-#include "libslic3r.h"
 #include "LocalesUtils.hpp"
 #include "libslic3r/format.hpp"
 #include "Time.hpp"

src/libslic3r/GCode/FanMover.cpp

@@ -27,8 +27,6 @@
 #include "../PrintConfig.hpp"
 #include "../Utils.hpp"
 #include "Print.hpp"
-#include "libslic3r/PrintConfig.hpp"
-#include "libslic3r/libslic3r.h"
 
 #include <boost/log/trivial.hpp>
 #include <string>

src/libslic3r/GCodeSender.cpp

@@ -1,580 +0,0 @@
-#include "GCodeSender.hpp"
-#include <iostream>
-#include <istream>
-#include <string>
-#include <thread>
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/trim.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/lexical_cast.hpp>
-
-#if defined(__APPLE__) || defined(__OpenBSD__)
-#include <termios.h>
-#endif
-#ifdef __APPLE__
-#include <sys/ioctl.h>
-#include <IOKit/serial/ioss.h>
-#endif
-#ifdef __linux__
-#include <sys/ioctl.h>
-#include <fcntl.h>
-#include "/usr/include/asm-generic/ioctls.h"
-
-/* The following definitions are kindly borrowed from:
-   /usr/include/asm-generic/termbits.h
-   Unfortunately we cannot just include that one because
-   it would redefine the "struct termios" already defined
-   the <termios.h> already included by Boost.ASIO. */
-#define K_NCCS 19
-struct termios2 {
-	tcflag_t c_iflag;
-	tcflag_t c_oflag;
-	tcflag_t c_cflag;
-	tcflag_t c_lflag;
-	cc_t c_line;
-	cc_t c_cc[K_NCCS];
-	speed_t c_ispeed;
-	speed_t c_ospeed;
-};
-#define BOTHER CBAUDEX
-
-#endif
-
-//#define DEBUG_SERIAL
-#ifdef DEBUG_SERIAL
-#include <cstdlib>
-#include <fstream>
-std::fstream fs;
-#endif
-
-#define KEEP_SENT 20
-
-namespace Slic3r {
-
-GCodeSender::GCodeSender()
-    : io(), serial(io), can_send(false), sent(0), open(false), error(false),
-      connected(false), queue_paused(false)
-{
-#ifdef DEBUG_SERIAL
-    std::srand(std::time(nullptr));
-#endif
-}
-
-GCodeSender::~GCodeSender()
-{
-    this->disconnect();
-}
-
-bool
-GCodeSender::connect(std::string devname, unsigned int baud_rate)
-{
-    this->disconnect();
-    
-    this->set_error_status(false);
-    try {
-        this->serial.open(devname);
-        
-        this->serial.set_option(boost::asio::serial_port_base::parity(boost::asio::serial_port_base::parity::odd));
-        this->serial.set_option(boost::asio::serial_port_base::character_size(boost::asio::serial_port_base::character_size(8)));
-        this->serial.set_option(boost::asio::serial_port_base::flow_control(boost::asio::serial_port_base::flow_control::none));
-        this->serial.set_option(boost::asio::serial_port_base::stop_bits(boost::asio::serial_port_base::stop_bits::one));
-        this->set_baud_rate(baud_rate);
-    
-        this->serial.close();
-        this->serial.open(devname);
-        this->serial.set_option(boost::asio::serial_port_base::parity(boost::asio::serial_port_base::parity::none));
-    
-        // set baud rate again because set_option overwrote it
-        this->set_baud_rate(baud_rate);
-        this->open = true;
-        this->reset();
-    } catch (boost::system::system_error &) {
-        this->set_error_status(true);
-        return false;
-    }
-    
-    // a reset firmware expect line numbers to start again from 1
-    this->sent = 0;
-    this->last_sent.clear();
-
-    /* Initialize debugger */
-#ifdef DEBUG_SERIAL
-    fs.open("serial.txt", std::fstream::out | std::fstream::trunc);
-#endif
-    
-    // this gives some work to the io_service before it is started
-    // (post() runs the supplied function in its thread)
-    this->io.post(boost::bind(&GCodeSender::do_read, this));
-    
-    // start reading in the background thread
-    boost::thread t(boost::bind(&boost::asio::io_service::run, &this->io));
-    this->background_thread.swap(t);
-    
-    // always send a M105 to check for connection because firmware might be silent on connect
-    //FIXME Vojtech: This is being sent too early, leading to line number synchronization issues,
-    // from which the GCodeSender never recovers.
-    // this->send("M105", true);
-    
-    return true;
-}
-
-void
-GCodeSender::set_baud_rate(unsigned int baud_rate)
-{
-    try {
-        // This does not support speeds > 115200
-        this->serial.set_option(boost::asio::serial_port_base::baud_rate(baud_rate));
-    } catch (boost::system::system_error &) {
-        boost::asio::serial_port::native_handle_type handle = this->serial.native_handle();
-
-#if __APPLE__
-        termios ios;
-        ::tcgetattr(handle, &ios);
-        ::cfsetspeed(&ios, baud_rate);
-        speed_t newSpeed = baud_rate;
-        ioctl(handle, IOSSIOSPEED, &newSpeed);
-        ::tcsetattr(handle, TCSANOW, &ios);
-#elif __linux__
-        termios2 ios;
-        if (ioctl(handle, TCGETS2, &ios))
-            printf("Error in TCGETS2: %s\n", strerror(errno));
-        ios.c_ispeed = ios.c_ospeed = baud_rate;
-        ios.c_cflag &= ~CBAUD;
-        ios.c_cflag |= BOTHER | CLOCAL | CREAD;
-        ios.c_cc[VMIN] = 1; // Minimum of characters to read, prevents eof errors when 0 bytes are read
-        ios.c_cc[VTIME] = 1;
-        if (ioctl(handle, TCSETS2, &ios))
-            printf("Error in TCSETS2: %s\n", strerror(errno));
-		
-#elif __OpenBSD__
-		struct termios ios;
-		::tcgetattr(handle, &ios);
-		::cfsetspeed(&ios, baud_rate);
-		if (::tcsetattr(handle, TCSAFLUSH, &ios) != 0)
-			printf("Failed to set baud rate: %s\n", strerror(errno));
-#else
-        //throw Slic3r::InvalidArgument("OS does not currently support custom bauds");
-#endif
-    }
-}
-
-void
-GCodeSender::disconnect()
-{
-    if (!this->open) return;
-    this->open = false;
-    this->connected = false;
-    this->io.post(boost::bind(&GCodeSender::do_close, this));
-    this->background_thread.join();
-    this->io.reset();
-    /*
-    if (this->error_status()) {
-        throw(boost::system::system_error(boost::system::error_code(),
-            "Error while closing the device"));
-    }
-    */
-    
-#ifdef DEBUG_SERIAL
-    fs << "DISCONNECTED" << std::endl << std::flush;
-    fs.close();
-#endif
-}
-
-bool
-GCodeSender::is_connected() const
-{
-    return this->connected;
-}
-
-bool
-GCodeSender::wait_connected(unsigned int timeout) const
-{
-    using namespace boost::posix_time;
-    ptime t0 = second_clock::local_time() + seconds(timeout);
-    while (!this->connected) {
-        if (second_clock::local_time() > t0) return false;
-        boost::this_thread::sleep(boost::posix_time::milliseconds(100));
-    }
-    return true;
-}
-
-size_t
-GCodeSender::queue_size() const
-{
-    boost::lock_guard<boost::mutex> l(this->queue_mutex);
-    return this->queue.size();
-}
-
-void
-GCodeSender::pause_queue()
-{
-    boost::lock_guard<boost::mutex> l(this->queue_mutex);
-    this->queue_paused = true;
-}
-
-void
-GCodeSender::resume_queue()
-{
-    {
-        boost::lock_guard<boost::mutex> l(this->queue_mutex);
-        this->queue_paused = false;
-    }
-    this->send();
-}
-
-void
-GCodeSender::purge_queue(bool priority)
-{
-    boost::lock_guard<boost::mutex> l(this->queue_mutex);
-    if (priority) {
-        // clear priority queue
-        std::list<std::string> empty;
-        std::swap(this->priqueue, empty);
-    } else {
-        // clear queue
-        std::queue<std::string> empty;
-        std::swap(this->queue, empty);
-        this->queue_paused = false;
-    }
-}
-
-// purge log and return its contents
-std::vector<std::string>
-GCodeSender::purge_log()
-{
-    boost::lock_guard<boost::mutex> l(this->log_mutex);
-    std::vector<std::string> retval;
-    retval.reserve(this->log.size());
-    while (!this->log.empty()) {
-        retval.push_back(this->log.front());
-        this->log.pop();
-    }
-    return retval;
-}
-
-std::string
-GCodeSender::getT() const
-{
-    boost::lock_guard<boost::mutex> l(this->log_mutex);
-    return this->T;
-}
-
-std::string
-GCodeSender::getB() const
-{
-    boost::lock_guard<boost::mutex> l(this->log_mutex);
-    return this->B;
-}
-
-void
-GCodeSender::do_close()
-{
-    this->set_error_status(false);
-    boost::system::error_code ec;
-    this->serial.cancel(ec);
-    if (ec) this->set_error_status(true);
-    this->serial.close(ec);
-    if (ec) this->set_error_status(true);
-}
-
-void
-GCodeSender::set_error_status(bool e)
-{
-    boost::lock_guard<boost::mutex> l(this->error_mutex);
-    this->error = e;
-}
-
-bool
-GCodeSender::error_status() const
-{
-    boost::lock_guard<boost::mutex> l(this->error_mutex);
-    return this->error;
-}
-
-void
-GCodeSender::do_read()
-{
-    // read one line
-    boost::asio::async_read_until(
-        this->serial,
-        this->read_buffer,
-        '\n',
-        boost::bind(
-            &GCodeSender::on_read,
-            this,
-            boost::asio::placeholders::error,
-            boost::asio::placeholders::bytes_transferred
-        )
-    );
-}
-
-void
-GCodeSender::on_read(const boost::system::error_code& error,
-    size_t bytes_transferred)
-{
-    this->set_error_status(false);
-    if (error) {
-        #ifdef __APPLE__
-        if (error.value() == 45) {
-            // OS X bug: http://osdir.com/ml/lib.boost.asio.user/2008-08/msg00004.html
-            this->do_read();
-            return;
-        }
-        #endif
-    
-        // printf("ERROR: [%d] %s\n", error.value(), error.message().c_str());
-        // error can be true even because the serial port was closed.
-        // In this case it is not a real error, so ignore.
-        if (this->open) {
-            this->do_close();
-            this->set_error_status(true);
-        }
-        return;
-    }
-    
-    std::istream is(&this->read_buffer);
-    std::string line;
-    std::getline(is, line);
-    if (!line.empty()) {
-#ifdef DEBUG_SERIAL
-    fs << "<< " << line << std::endl << std::flush;
-#endif
-        
-        // note that line might contain \r at its end
-        // parse incoming line
-        if (!this->connected
-            && (boost::starts_with(line, "start")
-             || boost::starts_with(line, "Grbl ")
-             || boost::starts_with(line, "ok")
-             || boost::contains(line, "T:"))) {
-            this->connected = true;
-            {
-                boost::lock_guard<boost::mutex> l(this->queue_mutex);
-                this->can_send = true;
-            }
-            this->send();
-        } else if (boost::starts_with(line, "ok")) {
-            {
-                boost::lock_guard<boost::mutex> l(this->queue_mutex);
-                this->can_send = true;
-            }
-            this->send();
-        } else if (boost::istarts_with(line, "resend")  // Marlin uses "Resend: "
-                || boost::istarts_with(line, "rs")) {
-            // extract the first number from line
-            boost::algorithm::trim_left_if(line, !boost::algorithm::is_digit());
-            size_t toresend = boost::lexical_cast<size_t>(line.substr(0, line.find_first_not_of("0123456789")));
-            
-#ifdef DEBUG_SERIAL
-            fs << "!! line num out of sync: toresend = " << toresend << ", sent = " << sent << ", last_sent.size = " << last_sent.size() << std::endl;
-#endif
-
-            if (toresend > this->sent - this->last_sent.size() && toresend <= this->sent) {
-                {
-                    boost::lock_guard<boost::mutex> l(this->queue_mutex);
-                    
-                    const auto lines_to_resend = this->sent - toresend + 1;
-#ifdef DEBUG_SERIAL
-            fs << "!! resending " << lines_to_resend << " lines" << std::endl;
-#endif
-                    // move the unsent lines to priqueue
-                    this->priqueue.insert(
-                        this->priqueue.begin(),  // insert at the beginning
-                        this->last_sent.begin() + this->last_sent.size() - lines_to_resend,
-                        this->last_sent.end()
-                    );
-                    
-                    // we can empty last_sent because it's not useful anymore
-                    this->last_sent.clear();
-                    
-                    // start resending with the requested line number
-                    this->sent = toresend - 1;
-                    this->can_send = true;
-                }
-                this->send();
-            } else {
-                printf("Cannot resend %zu (oldest we have is %zu)\n", toresend, this->sent - this->last_sent.size());
-            }
-        } else if (boost::starts_with(line, "wait")) {
-            // ignore
-        } else {
-            // push any other line into the log
-            boost::lock_guard<boost::mutex> l(this->log_mutex);
-            this->log.push(line);
-        }
-    
-        // parse temperature info
-        {
-            size_t pos = line.find("T:");
-            if (pos != std::string::npos && line.size() > pos + 2) {
-                // we got temperature info
-                boost::lock_guard<boost::mutex> l(this->log_mutex);
-                this->T = line.substr(pos+2, line.find_first_not_of("0123456789.", pos+2) - (pos+2));
-        
-                pos = line.find("B:");
-                if (pos != std::string::npos && line.size() > pos + 2) {
-                    // we got bed temperature info
-                    this->B = line.substr(pos+2, line.find_first_not_of("0123456789.", pos+2) - (pos+2));
-                }
-            }
-        }
-    }
-    this->do_read();
-}
-
-void
-GCodeSender::send(const std::vector<std::string> &lines, bool priority)
-{
-    // append lines to queue
-    {
-        boost::lock_guard<boost::mutex> l(this->queue_mutex);
-        for (std::vector<std::string>::const_iterator line = lines.begin(); line != lines.end(); ++line) {
-            if (priority) {
-                this->priqueue.push_back(*line);
-            } else {
-                this->queue.push(*line);
-            }
-        }
-    }
-    this->send();
-}
-
-void
-GCodeSender::send(const std::string &line, bool priority)
-{
-    // append line to queue
-    {
-        boost::lock_guard<boost::mutex> l(this->queue_mutex);
-        if (priority) {
-            this->priqueue.push_back(line);
-        } else {
-            this->queue.push(line);
-        }
-    }
-    this->send();
-}
-
-void
-GCodeSender::send()
-{
-    this->io.post(boost::bind(&GCodeSender::do_send, this));
-}
-
-void
-GCodeSender::do_send()
-{
-    boost::lock_guard<boost::mutex> l(this->queue_mutex);
-    
-    // printer is not connected or we're still waiting for the previous ack
-    if (!this->can_send) return;
-    
-    std::string line;
-    while (!this->priqueue.empty() || (!this->queue.empty() && !this->queue_paused)) {
-        if (!this->priqueue.empty()) {
-            line = this->priqueue.front();
-            this->priqueue.pop_front();
-        } else {
-            line = this->queue.front();
-            this->queue.pop();
-        }
-        
-        // strip comments
-        size_t comment_pos = line.find_first_of(';');
-        if (comment_pos != std::string::npos)
-            line.erase(comment_pos, std::string::npos);
-        boost::algorithm::trim(line);
-        
-        // if line is not empty, send it
-        if (!line.empty()) break;
-        // if line is empty, process next item in queue
-    }
-    if (line.empty()) return;
-    
-    // compute full line
-    ++ this->sent;
-#ifndef DEBUG_SERIAL
-    const auto line_num = this->sent;
-#else
-    // In DEBUG_SERIAL mode, test line re-synchronization by sending bad line number 1/4 of the time
-    const auto line_num = std::rand() < RAND_MAX/4 ? 0 : this->sent;
-#endif
-    std::string full_line = "N" + boost::lexical_cast<std::string>(line_num) + " " + line;
-    
-    // calculate checksum
-    int cs = 0;
-    for (std::string::const_iterator it = full_line.begin(); it != full_line.end(); ++it)
-       cs = cs ^ *it;
-    
-    // write line to device
-    full_line += "*";
-    full_line += boost::lexical_cast<std::string>(cs);
-    full_line += "\n";
-    
-#ifdef DEBUG_SERIAL
-    fs << ">> " << full_line << std::flush;
-#endif
-    
-    this->last_sent.push_back(line);
-    this->can_send = false;
-    
-    while (this->last_sent.size() > KEEP_SENT) {
-        this->last_sent.pop_front();
-    }
-    
-    // we can't supply boost::asio::buffer(full_line) to async_write() because full_line is on the
-    // stack and the buffer would lose its underlying storage causing memory corruption
-    std::ostream os(&this->write_buffer);
-    os << full_line;
-    boost::asio::async_write(this->serial, this->write_buffer, boost::bind(&GCodeSender::on_write, this, boost::asio::placeholders::error,
-                boost::asio::placeholders::bytes_transferred));
-}
-
-void
-GCodeSender::on_write(const boost::system::error_code& error,
-    size_t bytes_transferred)
-{
-    this->set_error_status(false);
-    if (error) {
-        if (this->open) {
-            this->do_close();
-            this->set_error_status(true);
-        }
-        return;
-    }
-    
-    this->do_send();
-}
-
-void
-GCodeSender::set_DTR(bool on)
-{
-#if defined(_WIN32) && !defined(__SYMBIAN32__)
-    boost::asio::serial_port_service::native_handle_type handle = this->serial.native_handle();
-    if (on)
-        EscapeCommFunction(handle, SETDTR);
-    else
-        EscapeCommFunction(handle, CLRDTR);
-#else
-    int fd = this->serial.native_handle();
-    int status;
-    ioctl(fd, TIOCMGET, &status);
-    if (on)
-        status |= TIOCM_DTR;
-    else
-        status &= ~TIOCM_DTR;
-    ioctl(fd, TIOCMSET, &status);
-#endif
-}
-
-void
-GCodeSender::reset()
-{
-    set_DTR(false);
-    std::this_thread::sleep_for(std::chrono::milliseconds(200));
-    set_DTR(true);
-    std::this_thread::sleep_for(std::chrono::milliseconds(200));
-    set_DTR(false);
-    std::this_thread::sleep_for(std::chrono::milliseconds(500));
-}
-
-} // namespace Slic3r

src/libslic3r/GCodeSender.hpp

@@ -1,81 +0,0 @@
-#ifndef slic3r_GCodeSender_hpp_
-#define slic3r_GCodeSender_hpp_
-
-#include "libslic3r.h"
-#include <queue>
-#include <boost/core/noncopyable.hpp>
-#include <cstddef>
-#include <boost/asio/io_service.hpp>
-#include <boost/asio/serial_port.hpp>
-#include <boost/asio/streambuf.hpp>
-#include <list>
-#include <deque>
-#include <string>
-#include <vector>
-#include <boost/asio.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/bind/bind.hpp>
-#include <boost/thread.hpp>
-
-namespace Slic3r {
-
-namespace asio = boost::asio;
-
-class GCodeSender : private boost::noncopyable {
-    public:
-    GCodeSender();
-    ~GCodeSender();
-    bool connect(std::string devname, unsigned int baud_rate);
-    void send(const std::vector<std::string> &lines, bool priority = false);
-    void send(const std::string &s, bool priority = false);
-    void disconnect();
-    bool error_status() const;
-    bool is_connected() const;
-    bool wait_connected(unsigned int timeout = 3) const;
-    size_t queue_size() const;
-    void pause_queue();
-    void resume_queue();
-    void purge_queue(bool priority = false);
-    std::vector<std::string> purge_log();
-    std::string getT() const;
-    std::string getB() const;
-    void set_DTR(bool on);
-    void reset();
-    
-    private:
-    asio::io_service io;
-    asio::serial_port serial;
-    boost::thread background_thread;
-    boost::asio::streambuf read_buffer, write_buffer;
-    bool open;      // whether the serial socket is connected
-    bool connected; // whether the printer is online
-    bool error;
-    mutable boost::mutex error_mutex;
-    
-    // this mutex guards queue, priqueue, can_send, queue_paused, sent, last_sent
-    mutable boost::mutex queue_mutex;
-    std::queue<std::string> queue;
-    std::list<std::string> priqueue;
-    bool can_send;
-    bool queue_paused;
-    size_t sent;
-    std::deque<std::string> last_sent;
-    
-    // this mutex guards log, T, B
-    mutable boost::mutex log_mutex;
-    std::queue<std::string> log;
-    std::string T, B;
-    
-    void set_baud_rate(unsigned int baud_rate);
-    void set_error_status(bool e);
-    void do_send();
-    void on_write(const boost::system::error_code& error, size_t bytes_transferred);
-    void do_close();
-    void do_read();
-    void on_read(const boost::system::error_code& error, size_t bytes_transferred);
-    void send();
-};
-
-} // namespace Slic3r
-
-#endif /* slic3r_GCodeSender_hpp_ */

src/libslic3r/Geometry/MedialAxis.cpp

@@ -1,7 +1,6 @@
 #include <boost/log/trivial.hpp>
 #include "MedialAxis.hpp"
 
-#include <boost/log/trivial.hpp>
 #include <boost/polygon/polygon.hpp>
 #include <cassert>
 #include <cmath>

src/libslic3r/Model.cpp

@@ -22,7 +22,6 @@
 #include "Format/AssimpImport.hpp"
 #include "ClipperUtils.hpp"
 #include "Exception.hpp"
-#include "Model.hpp"
 #include "ModelArrange.hpp"
 #include "Arrange.hpp"
 #include "Geometry.hpp"

src/libslic3r/Model.hpp

@@ -18,7 +18,6 @@
 #include "TriangleMesh.hpp"
 #include "CustomGCode.hpp"
 #include "calib.hpp"
-#include "enum_bitmask.hpp"
 #include "TextConfiguration.hpp"
 #include "EmbossShape.hpp"
 #include "TriangleSelector.hpp"

src/libslic3r/Shape/TextShape.cpp

@@ -44,7 +44,6 @@
 #include "TDataStd_Name.hxx"
 #include "BRepBuilderAPI_Transform.hxx"
 #include "TopExp_Explorer.hxx"
-#include "TopExp_Explorer.hxx"
 #include "BRep_Tool.hxx"
 #include "Font_BRepFont.hxx"
 #include "Font_BRepTextBuilder.hxx"

src/libslic3r/Utils.hpp

@@ -25,8 +25,6 @@
 #include <initializer_list>
 #include <string_view>
 #include <regex>
-#include <string_view>
-#include <algorithm>
 
 #include <boost/system/error_code.hpp>
 #include <boost/algorithm/string.hpp>

src/slic3r/GUI/AmsMappingPopup.hpp

@@ -17,7 +17,6 @@
 #include <wx/dataview.h>
 #include <wx/artprov.h>
 #include <wx/xrc/xmlres.h>
-#include <wx/dataview.h>
 #include <wx/gdicmn.h>
 #include <wx/font.h>
 #include <wx/colour.h>
@@ -30,7 +29,6 @@
 #include <wx/dialog.h>
 #include <wx/popupwin.h>
 #include <wx/spinctrl.h>
-#include <wx/artprov.h>
 #include <wx/wrapsizer.h>
 
 #include "GUI_Utils.hpp"

src/slic3r/GUI/AmsWidgets.hpp

@@ -19,20 +19,17 @@
 #include <wx/font.h>
 #include <wx/colour.h>
 #include <wx/settings.h>
-#include <wx/sizer.h>
 #include <wx/grid.h>
 #include <wx/dataview.h>
 #include <wx/panel.h>
 #include <wx/bitmap.h>
 #include <wx/image.h>
 #include <wx/icon.h>
-#include <wx/bmpbuttn.h>
 #include <wx/button.h>
 #include <wx/statbox.h>
 #include <wx/tglbtn.h>
 #include <wx/popupwin.h>
 #include <wx/spinctrl.h>
-#include <wx/artprov.h>
 
 
 #include <map>

src/slic3r/GUI/Auxiliary.hpp

@@ -28,7 +28,6 @@
 #include <wx/font.h>
 #include <wx/colour.h>
 #include <wx/settings.h>
-#include <wx/sizer.h>
 #include <wx/grid.h>
 #include <wx/dataview.h>
 #include <wx/panel.h>
@@ -36,14 +35,12 @@
 #include <wx/bitmap.h>
 #include <wx/image.h>
 #include <wx/icon.h>
-#include <wx/bmpbuttn.h>
 #include <wx/button.h>
 #include <wx/gbsizer.h>
 #include <wx/statbox.h>
 #include <wx/tglbtn.h>
 #include <wx/popupwin.h>
 #include <wx/spinctrl.h>
-#include <wx/artprov.h>
 #include <wx/webrequest.h>
 #include <map>
 #include <vector>

src/slic3r/GUI/BBLStatusBar.hpp

@@ -8,7 +8,6 @@
 #include <memory>
 #include <string>
 #include <functional>
-#include <string>
 
 #include "Jobs/ProgressIndicator.hpp"
 

src/slic3r/GUI/BBLStatusBarBind.hpp

@@ -10,7 +10,6 @@
 #include <memory>
 #include <string>
 #include <functional>
-#include <string>
 #include <wx/string.h>
 #include "Jobs/ProgressIndicator.hpp"
 

src/slic3r/GUI/BBLStatusBarPrint.hpp

@@ -9,7 +9,6 @@
 #include <memory>
 #include <string>
 #include <functional>
-#include <string>
 #include <wx/hyperlink.h>
 
 #include "Jobs/ProgressIndicator.hpp"

src/slic3r/GUI/BBLStatusBarSend.hpp

@@ -9,7 +9,6 @@
 #include <memory>
 #include <string>
 #include <functional>
-#include <string>
 #include <wx/hyperlink.h>
 
 #include "Jobs/ProgressIndicator.hpp"

src/slic3r/GUI/BaseTransparentDPIFrame.cpp

@@ -18,7 +18,6 @@
 #include <wx/string.h>
 #include <wx/toplevel.h>
 #include <wx/timer.h>
-#include "Widgets/Button.hpp"
 #include "CapsuleButton.hpp"
 
 namespace Slic3r::GUI { struct IntEvent; }

src/slic3r/GUI/BindDialog.cpp

@@ -46,7 +46,6 @@
 #include "libslic3r/Model.hpp"
 #include "libslic3r/Polygon.hpp"
 #include "MainFrame.hpp"
-#include "GUI_App.hpp"
 #include "Plater.hpp"
 #include "Jobs/BoostThreadWorker.hpp"
 #include "Jobs/PlaterWorker.hpp"

src/slic3r/GUI/BonjourDialog.cpp

@@ -29,7 +29,6 @@
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/format.hpp"
-#include "slic3r/Utils/Bonjour.hpp"
 
 #include "slic3r/GUI/Widgets/DialogButtons.hpp"
 

src/slic3r/GUI/Calibration.hpp

@@ -11,7 +11,6 @@
 #include <wx/dataview.h>
 #include <wx/artprov.h>
 #include <wx/xrc/xmlres.h>
-#include <wx/dataview.h>
 #include <wx/gdicmn.h>
 #include <wx/font.h>
 #include <wx/colour.h>
@@ -24,7 +23,6 @@
 #include <wx/dialog.h>
 #include <wx/popupwin.h>
 #include <wx/spinctrl.h>
-#include <wx/artprov.h>
 #include <wx/wrapsizer.h>
 
 #include "GUI_Utils.hpp"

src/slic3r/GUI/ConfigManipulation.cpp

@@ -1,4 +1,3 @@
-// #include "libslic3r/GCodeSender.hpp"
 #include "ConfigManipulation.hpp"
 #include "I18N.hpp"
 #include "GUI_App.hpp"

src/slic3r/GUI/DeviceCore/DevFilaSystem.h

@@ -15,7 +15,6 @@
 #include <memory>
 #include <unordered_map>
 #include <unordered_set>
-#include <vector>
 #include <wx/string.h>
 #include <wx/colour.h>
 

src/slic3r/GUI/DeviceManager.cpp

@@ -11,7 +11,6 @@
 #include "GUI_App.hpp"
 #include "DeviceErrorDialog.hpp"
 #include "Plater.hpp"
-#include "GUI_App.hpp"
 #include "ReleaseNote.hpp"
 #include <string>
 #include <boost/log/trivial.hpp>

src/slic3r/GUI/GLTexture.cpp

@@ -46,7 +46,6 @@
 #include "nanosvg/nanosvgrast.h"
 
 #include "libslic3r/Utils.hpp"
-#include "GUI_App.hpp"
 #include <boost/log/trivial.hpp>
 #include <wx/dcgraph.h>
 #include <wx/dcmemory.h>

src/slic3r/GUI/GUI.cpp

@@ -50,7 +50,6 @@
 #include "AboutDialog.hpp"
 #include "MsgDialog.hpp"
 #include "Plater.hpp"
-#include "format.hpp"
 
 #include "WebUserLoginDialog.hpp"
 

src/slic3r/GUI/GUI_App.cpp

@@ -172,12 +172,10 @@
 
 #include "libslic3r/Utils.hpp"
 #include "libslic3r/Model.hpp"
-#include "libslic3r/I18N.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "libslic3r/InstanceLock.hpp"
 #include "libslic3r/Thread.hpp"
 #include "libslic3r/miniz_extension.hpp"
-#include "libslic3r/Utils.hpp"
 #include "slic3r/plugin/PluginManager.hpp"
 #include "slic3r/plugin/host/PluginHostUi.hpp"
 #include "slic3r/plugin/PythonInterpreter.hpp"

src/slic3r/GUI/HintNotification.cpp

@@ -11,7 +11,6 @@
 #include "libslic3r/Config.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "libslic3r/Preset.hpp"
-#include "libslic3r/Config.hpp"
 #include "libslic3r/PrintConfig.hpp"
 
 #include <cstdint>

src/slic3r/GUI/ImGuiWrapper.cpp

@@ -66,7 +66,6 @@
 #include <nanosvg/nanosvg.h>
 #include <nanosvg/nanosvgrast.h>
 #include "OpenGLManager.hpp"
-#include "GUI_App.hpp"
 
 namespace Slic3r {
 namespace GUI {

src/slic3r/GUI/MainFrame.cpp

@@ -113,7 +113,6 @@
 #include "MsgDialog.hpp"
 #include "Notebook.hpp"
 #include "GUI_Factories.hpp"
-#include "GUI_ObjectList.hpp"
 #include "NotificationManager.hpp"
 #include "MarkdownTip.hpp"
 #include "NetworkTestDialog.hpp"

src/slic3r/GUI/ModelMall.cpp

@@ -21,7 +21,6 @@
 #include "wx/evtloop.h"
 
 #include "MainFrame.hpp"
-#include "GUI_App.hpp"
 #include "Plater.hpp"
 
 using json = nlohmann::json;

src/slic3r/GUI/Monitor.cpp

@@ -45,7 +45,6 @@
 #include "MainFrame.hpp"
 #include "MediaPlayCtrl.h"
 #include "MediaFilePanel.h"
-#include "Plater.hpp"
 #include "BindDialog.hpp"
 
 #include "DeviceCore/DevManager.h"

src/slic3r/GUI/Monitor.hpp

@@ -23,7 +23,6 @@
 #include <wx/font.h>
 #include <wx/colour.h>
 #include <wx/settings.h>
-#include <wx/sizer.h>
 #include <wx/grid.h>
 #include <wx/dataview.h>
 #include <wx/panel.h>
@@ -31,14 +30,12 @@
 #include <wx/bitmap.h>
 #include <wx/image.h>
 #include <wx/icon.h>
-#include <wx/bmpbuttn.h>
 #include <wx/button.h>
 #include <wx/gbsizer.h>
 #include <wx/statbox.h>
 #include <wx/tglbtn.h>
 #include <wx/popupwin.h>
 #include <wx/spinctrl.h>
-#include <wx/artprov.h>
 #include <wx/webrequest.h>
 #include <map>
 #include <vector>

src/slic3r/GUI/NetworkTestDialog.cpp

@@ -4,7 +4,6 @@
 #include "libslic3r/Utils.hpp"
 #include "GUI.hpp"
 #include "GUI_App.hpp"
-#include "I18N.hpp"
 #include "libslic3r_version.h"
 #include "slic3r/Utils/Http.hpp"
 #include "libslic3r/AppConfig.hpp"

src/slic3r/GUI/PresetBundleDialog.cpp

@@ -30,7 +30,6 @@
 #include "MainFrame.hpp"
 #include <miniz.h>
 #include <OrcaCloudServiceAgent.hpp>
-#include <wx/event.h>
 #include <wx/utils.h>
 
 using json = nlohmann::json;

src/slic3r/GUI/PrintHostDialogs.cpp

@@ -79,7 +79,6 @@
 #include "libslic3r_version.h"
 #include "wxExtensions.hpp"
 
-#include <nlohmann/json.hpp>
 #include "libslic3r/Preset.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/Widgets/Button.hpp"

src/slic3r/GUI/ProgressStatusBar.hpp

@@ -4,7 +4,6 @@
 #include <memory>
 #include <string>
 #include <functional>
-#include <string>
 
 #include "Jobs/ProgressIndicator.hpp"
 

src/slic3r/GUI/ReleaseNote.hpp

@@ -19,7 +19,6 @@
 #include <wx/dataview.h>
 #include <wx/artprov.h>
 #include <wx/xrc/xmlres.h>
-#include <wx/dataview.h>
 #include <wx/gdicmn.h>
 #include <wx/font.h>
 #include <wx/colour.h>
@@ -32,10 +31,8 @@
 #include <wx/dialog.h>
 #include <wx/popupwin.h>
 #include <wx/spinctrl.h>
-#include <wx/artprov.h>
 #include <wx/wrapsizer.h>
 #include <wx/event.h>
-#include <wx/hyperlink.h>
 #include <wx/richtext/richtextctrl.h>
 
 #include "AmsMappingPopup.hpp"

src/slic3r/GUI/SelectMachine.hpp

@@ -25,7 +25,6 @@
 #include <wx/dataview.h>
 #include <wx/artprov.h>
 #include <wx/xrc/xmlres.h>
-#include <wx/dataview.h>
 #include <wx/gdicmn.h>
 #include <wx/font.h>
 #include <wx/colour.h>
@@ -38,7 +37,6 @@
 #include <wx/dialog.h>
 #include <wx/popupwin.h>
 #include <wx/spinctrl.h>
-#include <wx/artprov.h>
 #include <wx/wrapsizer.h>
 #include <wx/srchctrl.h>
 

src/slic3r/GUI/SelectMachinePop.hpp

@@ -16,7 +16,6 @@
 #include <wx/dataview.h>
 #include <wx/artprov.h>
 #include <wx/xrc/xmlres.h>
-#include <wx/dataview.h>
 #include <wx/gdicmn.h>
 #include <wx/font.h>
 #include <wx/colour.h>
@@ -29,7 +28,6 @@
 #include <wx/dialog.h>
 #include <wx/popupwin.h>
 #include <wx/spinctrl.h>
-#include <wx/artprov.h>
 #include <wx/wrapsizer.h>
 #include <wx/srchctrl.h>
 

src/slic3r/GUI/SendToPrinter.hpp

@@ -20,7 +20,6 @@
 #include <wx/dataview.h>
 #include <wx/artprov.h>
 #include <wx/xrc/xmlres.h>
-#include <wx/dataview.h>
 #include <wx/gdicmn.h>
 #include <wx/font.h>
 #include <wx/colour.h>
@@ -33,7 +32,6 @@
 #include <wx/dialog.h>
 #include <wx/popupwin.h>
 #include <wx/spinctrl.h>
-#include <wx/artprov.h>
 #include <wx/wrapsizer.h>
 #include <wx/srchctrl.h>
 

src/slic3r/GUI/Tab.cpp

@@ -1,4 +1,3 @@
-// #include "libslic3r/GCodeSender.hpp"
 //#include "slic3r/Utils/Serial.hpp"
 #include "Tab.hpp"
 #include "PresetHints.hpp"
@@ -102,8 +101,6 @@
 #include "Widgets/MultiNozzleSync.hpp"
 #include "Widgets/SwitchButton.hpp"
 #include "Widgets/TabCtrl.hpp"
-#include "Widgets/ComboBox.hpp"
-#include "Search.hpp"
 #include "BedShapeDialog.hpp"
 #include "libslic3r/GCode/Thumbnails.hpp"
 #include "WipeTowerDialog.hpp"

src/slic3r/Utils/BBLPrinterAgent.cpp

@@ -204,9 +204,8 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
         int dir = input_val > 0 ? 1 : -1;
         // i3-arch printers move the bed for Y/Z, so the on-screen direction is
         // reversed -- same negation the g-code fallback below applies.
-        if (!is_core_xy && (axis == "Y" || axis == "Z")) {
+        if (!is_core_xy && (axis == "Y" || axis == "Z"))
             dir = -dir;
-        }
 
         j["print"]["command"] = "xyz_ctrl";
         j["print"]["axis"] = axis;
@@ -216,9 +215,8 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
     }
 
     double value = input_val;
-    if (!is_core_xy && (axis == "Y" || axis == "Z")) {
-        value = -1.0 * input_val;
-    }
+    if (!is_core_xy && (axis == "Y" || axis == "Z"))
+        value = -input_val;
 
     std::string value_str = (boost::format("%.1f") % (value * unit)).str();
     std::string gcode;
@@ -239,11 +237,10 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
 int BBLPrinterAgent::publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode)
 {
     const int rtn = lan_mode ? send_message_to_printer(dev_id, j.dump(), 0, 0) : send_message(dev_id, j.dump(), 0, 0);
-    if (rtn == 0) {
+    if (rtn == 0)
         BOOST_LOG_TRIVIAL(info) << "publish_json: " << j.dump() << " code: " << rtn;
-    } else {
+    else
         BOOST_LOG_TRIVIAL(error) << "publish_json: " << j.dump() << " code: " << rtn;
-    }
     return rtn;
 }
 
@@ -589,21 +586,8 @@ int BBLPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateS
 
 int BBLPrinterAgent::start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
 {
-    // dispatch_start() moves out of `params`, so snapshot the diagnostic fields first;
-    // logging them after the call would print empty strings.
-    const bool        try_emmc_print = params.try_emmc_print;
-    const std::string dev_ip         = params.dev_ip;
-    const std::string dev_id         = params.dev_id;
-
-    int result = dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
+    return dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
         BBLNetworkPlugin::instance().get_start_send_gcode_to_sdcard(), params, update_fn, cancel_fn, wait_fn);
-    if (result != 0) {
-        BOOST_LOG_TRIVIAL(error) << "start_send_gcode_to_sdcard failed: result=" << result
-            << ", try_emmc_print=" << try_emmc_print
-            << ", legacy_mode=" << BBLNetworkPlugin::instance().use_legacy_network()
-            << ", dev_ip=" << dev_ip << ", dev_id=" << dev_id;
-    }
-    return result;
 }
 
 int BBLPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)

src/slic3r/Utils/BBLPrinterAgent.hpp

@@ -110,7 +110,6 @@ public:
     static std::string from_orca_payload(std::string json_text);
 
 private:
-    // why: the lan/cloud DECISION stays machine-side; keep this mechanical branch in sync with publish_json.
     int publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode);
 };
 

src/slic3r/Utils/CalibUtils.cpp

@@ -20,8 +20,6 @@
 #include "../GUI/DeviceCore/DevConfig.h"
 #include "../GUI/DeviceCore/DevExtruderSystem.h"
 #include "../GUI/DeviceCore/DevManager.h"
-#include "../GUI/DeviceCore/DevStorage.h"
-#include "libslic3r/FlushVolCalc.hpp"
 #include "../GUI/Plater.hpp"
 #include <memory>
 #include "slic3r/GUI/Jobs/Worker.hpp"

src/slic3r/Utils/CrealityPrintAgent.cpp

@@ -288,14 +288,9 @@ bool CrealityPrintAgent::parse_cfs_response(const std::string&    response,
     return true;
 }
 
-bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    if (sync_mode != get_filament_sync_mode())
-        return false;
-
-    const MoonrakerDeviceInfo info = snapshot_device_info();
-
-    if (info.dev_ip.empty()) {
+    if (device_info.dev_ip.empty()) {
         BOOST_LOG_TRIVIAL(warning)
             << "CrealityPrintAgent::fetch_filament_info: no device IP, falling back to base agent";
         return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
@@ -304,11 +299,11 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
     // Build a CrealityPrint helper so we can use its model detection + WS helpers
     // (added in upstream PR #13291).
     DynamicPrintConfig cfg;
-    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + info.dev_ip));
+    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + device_info.dev_ip));
     cfg.set_key_value("print_host_webui",            new ConfigOptionString(""));
     cfg.set_key_value("printhost_cafile",            new ConfigOptionString(""));
     cfg.set_key_value("printhost_port",              new ConfigOptionString(""));
-    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(info.api_key));
+    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(device_info.api_key));
     cfg.set_key_value("printhost_ssl_ignore_revoke", new ConfigOptionBool(false));
 
     CrealityPrint host(&cfg);

src/slic3r/Utils/CrealityPrintAgent.hpp

@@ -37,7 +37,7 @@ public:
     };
 
     explicit CrealityPrintAgent(std::string log_dir);
-    ~CrealityPrintAgent() override { shutdown(); }
+    ~CrealityPrintAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }

src/slic3r/Utils/EmbossStyleManager.cpp

@@ -365,7 +365,6 @@ void StyleManager::init_trunc_names(float max_width) {
 #include "slic3r/GUI/Plater.hpp" 
 
 // for get DPI
-#include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/MainFrame.hpp"
 #include "slic3r/GUI/Gizmos/GizmoObjectManipulation.hpp"
 
@@ -554,8 +553,6 @@ bool StyleManager::set_wx_font(const wxFont &wx_font, std::unique_ptr<FontFile>
     return true;
 }
 
-#include <libslic3r/AppConfig.hpp>
-#include "WxFontUtils.hpp"
 #include "fast_float/fast_float.h"
 
 // StylesSerializable

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -12,10 +12,6 @@
 #include <set>
 #include <string>
 #include <thread>
-#include <chrono>
-#include <condition_variable>
-#include <deque>
-#include <functional>
 
 #include <nlohmann/json.hpp>
 #include <vector>
@@ -24,56 +20,6 @@ namespace Slic3r { class ICloudServiceAgent; }
 
 namespace Slic3r {
 
-class Http;
-
-bool moonraker_is_light_name(const std::string& name);
-// Direction encoded by a light name: +1 turns on, -1 turns off, 0 is an ambiguous toggle.
-// e.g. LIGHT_ON -> +1, LIGHT_OFF -> -1, LIGHT -> 0.
-int moonraker_light_name_direction(const std::string& name);
-
-struct MoonrakerWebcamSelection
-{
-    std::string      url;
-    CameraStreamMode mode = CameraStreamMode::none;
-    std::string      name;
-    std::string      error;  // set when no selectable webcam was found
-};
-
-// Selects a webcam from a parsed /server/webcams/list response (the top-level JSON or its
-// "result" value). Returns true and fills url/mode/name on success; on failure returns
-// false and sets error.
-bool moonraker_parse_webcam_list(const nlohmann::json& response, const std::string& base_url,
-                                 MoonrakerWebcamSelection& out);
-
-class MoonrakerWebsocket
-{
-public:
-    enum class ReadResult
-    {
-        message,
-        timeout,
-        closed,
-        error,
-    };
-
-    MoonrakerWebsocket(bool secure, std::string api_key, std::string ca_file);
-    ~MoonrakerWebsocket();
-
-    void connect(const std::string& host, const std::string& port, std::chrono::seconds timeout);
-    void tls_handshake(const std::string& host);
-    void handshake(const std::string& host, const std::string& target);
-    void text(bool enabled);
-    void write(const std::string& body);
-    ReadResult read(std::string& payload, std::string& error_message);
-    void close();
-    void expires_after(std::chrono::seconds timeout);
-    void abort();
-
-private:
-    struct Impl;
-    std::unique_ptr<Impl> m_impl;
-};
-
 class MoonrakerPrinterAgent : public IPrinterAgent
 {
 public:
@@ -119,24 +65,12 @@ public:
     int set_on_local_connect_fn(OnLocalConnectedFn fn) override;
     int set_on_local_message_fn(OnMessageFn fn) override;
     int set_queue_on_main_fn(QueueOnMainFn fn) override;
-    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
-    CameraStreamMode get_camera_stream_mode() const override;
-    std::string get_camera_url() const override;
 
-    // Called by the fetch-thread RAII guard when a background filament fetch finishes.
-    // Serialized with the reservation so shutdown()'s wait cannot miss the transition to 0.
-    void release_fetch_slot() noexcept;
+    // Pull-mode agent (on-demand filament sync)
+    FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::pull; }
+    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
 protected:
-    struct ConnectionSettings
-    {
-        std::string dev_id;
-        std::string base_url;
-        std::string api_key;
-        bool        use_ssl = false;
-        std::string ca_file;
-    };
-
     struct MoonrakerDeviceInfo
     {
         std::string dev_id;
@@ -148,9 +82,7 @@ protected:
         std::string dev_name;
         std::string version;
         std::string klippy_state;
-        float       nozzle_diameter = 0.0f;
         bool        use_ssl = false;
-        std::string ca_file;
     } device_info;
 
     // Tray data for AMS payload building
@@ -168,29 +100,12 @@ protected:
     void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
 
     // Methods that derived classes may need to override or access
-    virtual bool init_device_info(const PrinterConnectionParams& params);
-    virtual bool fetch_device_info(const ConnectionSettings& connection, MoonrakerDeviceInfo& info, std::string& error) const;
-    ConnectionSettings get_connection_settings() const;
-    // Copy of the mutable connection state, taken under connect_mutex. Background threads
-    // must use this instead of reading device_info directly.
-    MoonrakerDeviceInfo snapshot_device_info() const;
-    void configure_http(Http& http, const ConnectionSettings& connection) const;
-    static float parse_nozzle_diameter(const nlohmann::json& response);
+    virtual bool init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port);
+    virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
 
     // State access for derived classes
     mutable std::recursive_mutex       state_mutex;
 
-    // Detached fetch threads hold a raw `this`; shutdown() waits for this to reach 0.
-    std::atomic<int> filament_fetch_in_flight{0};
-
-    // Idempotent teardown; must be called from the most-derived destructor.
-    void shutdown();
-    std::atomic<bool> shutting_down{false};
-
-    // Serializes the shutting_down check with the in-flight reservation.
-    std::mutex fetch_lifecycle_mutex;
-    std::condition_variable fetch_done_cv;  // notified when filament_fetch_in_flight reaches 0
-
     // Helpers
     bool        is_numeric(const std::string& value);
     std::string normalize_base_url(bool use_ssl, const std::string& host, const std::string& port);
@@ -203,30 +118,13 @@ protected:
     // Map filament type to OrcaFilamentLibrary preset ID for AMS sync compatibility
     static std::string map_filament_type_to_generic_id(const std::string& filament_type);
 
-    // Send a G-code script via Moonraker (/printer/gcode/script)
-    bool send_gcode(const std::string& dev_id, const std::string& gcode) const;
-    bool send_gcode(const std::string& dev_id, const std::string& gcode,
-                    const ConnectionSettings& connection) const;
-    bool post_print_action(const std::string& action) const;
-    bool post_print_action(const std::string& action,
-                           const ConnectionSettings& connection) const;
-
-    bool send_ws_rpc(const std::string& method, const nlohmann::json& params);
-
-    virtual void on_status_loop_tick(const std::string& dev_id) {}
-
-    // Queue work that may use agent state. The command worker is joined during
-    // destruction, so queued commands cannot outlive the agent.
-    void enqueue_command(std::function<void()> fn);
-    mutable std::recursive_mutex connect_mutex;
-
 private:
     int handle_request(const std::string& dev_id, const std::string& json_str);
     int send_version_info(const std::string& dev_id);
     int send_access_code(const std::string& dev_id);
 
-    bool fetch_object_list(const ConnectionSettings& connection, std::set<std::string>& objects, std::string& error) const;
-    bool query_printer_status(const ConnectionSettings& connection, nlohmann::json& status, std::string& error) const;
+    bool fetch_object_list(const std::string& base_url, const std::string& api_key, std::set<std::string>& objects, std::string& error) const;
+    bool query_printer_status(const std::string& base_url, const std::string& api_key, nlohmann::json& status, std::string& error) const;
     bool send_gcode_sync(const std::string& dev_id, const std::string& gcode) const;
     void send_gcode_async(const std::string& dev_id, const std::string& gcode,
                           std::function<void(bool)> on_result = {}) const;
@@ -234,48 +132,37 @@ private:
     void announce_printhost_device();
     void dispatch_local_connect(int state, const std::string& dev_id, const std::string& msg);
     void dispatch_printer_connected(const std::string& dev_id);
-
-    // Self-contained snapshot of the message callbacks. Async completions capture this
-    // by value so they never dereference `this` after the agent may have been destroyed.
-    struct MessageRouter
-    {
-        OnMessageFn   local_fn;
-        OnMessageFn   cloud_fn;
-        QueueOnMainFn queue_fn;
-        std::string   dev_id;
-
-        void deliver(std::string payload) const;
-    };
-
-    MessageRouter make_message_router(const std::string& dev_id) const;
     void dispatch_message(const std::string& dev_id, const std::string& payload);
-    void start_status_stream(const std::string& dev_id, ConnectionSettings connection);
+    void start_status_stream(const std::string& dev_id, const std::string& base_url, const std::string& api_key);
     void stop_status_stream();
-    void run_status_stream(std::string dev_id, ConnectionSettings connection);
-    void handle_ws_message(std::string dev_id, std::string payload, ConnectionSettings connection);
-    void refresh_thumbnail_url(const ConnectionSettings& connection);
+    void run_status_stream(std::string dev_id, std::string base_url, std::string api_key);
+    void handle_ws_message(const std::string& dev_id, const std::string& payload);
     void update_status_cache(const nlohmann::json& updates);
     nlohmann::json build_print_payload_locked() const;
 
+    // Print control helpers
+    int pause_print(const std::string& dev_id);
+    int resume_print(const std::string& dev_id);
+    int cancel_print(const std::string& dev_id);
+
     // File upload
     bool upload_gcode(const std::string& local_path, const std::string& filename,
-                      const ConnectionSettings& connection,
+                      const std::string& base_url, const std::string& api_key,
                       OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
 
+    // JSON-RPC helper
+    bool send_jsonrpc_command(const std::string& base_url, const std::string& api_key,
+                              const nlohmann::json& request, std::string& response) const;
+
     // Connection thread management
     void perform_connection_async(const std::string& dev_id,
-                                   ConnectionSettings connection,
+                                   const std::string& base_url,
+                                   const std::string& api_key,
                                    uint64_t generation);
 
-    // why: a printer with no /server/webcams/list entry can still name its stream directly;
-    // subclasses (e.g. printers with a fixed webcam path) can override this instead.
-    virtual std::string webcam_stream_override(const std::string& base_url) const { return {}; }
-    void refresh_webcam_info() const;
-    bool fetch_webcam_info(const ConnectionSettings& connection, uint64_t generation) const;
-
     // System-specific filament fetch methods
-    bool fetch_hh_filament_info(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
-    bool fetch_moonraker_filament_data(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_hh_filament_info(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_moonraker_filament_data(std::vector<AmsTrayData>& trays, int& max_lane_index);
 
     // JSON helper methods
     static std::string safe_json_string(const nlohmann::json& obj, const char* key);
@@ -301,43 +188,15 @@ private:
 
     mutable std::recursive_mutex payload_mutex;
     nlohmann::json     status_cache;
-    // note: guarded by payload_mutex; filled by refresh_thumbnail_url(), empty url = looked up, none found
-    std::string        thumbnail_filename;
-    std::string        thumbnail_url;
-    mutable std::string        webcam_stream_url;
-    mutable CameraStreamMode   webcam_stream_mode = CameraStreamMode::none;
-    // Next time the status loop may look the webcam up again (steady_clock ms).
-    mutable std::atomic<uint64_t> webcam_info_next_attempt_ms{0};
-    unsigned            thumbnail_lookup_attempts = 0;
-
-    static constexpr uint64_t WEBCAM_INFO_REFRESH_INTERVAL_MS = 30000;
-    static constexpr uint64_t WEBCAM_INFO_FAILURE_BACKOFF_MS  = 60000;
 
     std::atomic<int>       next_jsonrpc_id{1};
     std::set<std::string>  available_objects;  // Track for feature detection
-    bool                   assumed_light_on = false;
 
     std::atomic<bool>   ws_stop{false};
     std::atomic<bool>   ws_reconnect_requested{false};  // Flag to trigger reconnection
     std::atomic<uint64_t> ws_last_emit_ms{0};
     std::thread         ws_thread;
 
-    // stop_status_stream() invokes ws_abort_io to wake a blocked synchronous
-    // ws.read()/ws.write()/handshake in run_status_stream(): ws_stop is only
-    // observed between reads, and Beast's expires_after() does not bound
-    // synchronous operations.
-    std::mutex             ws_abort_mutex;
-    std::function<void()>  ws_abort_io;  // guarded by ws_abort_mutex
-
-    // Interrupts the exponential reconnect backoff in run_status_stream() when stopping.
-    std::mutex              ws_wait_mutex;
-    std::condition_variable ws_wait_cv;
-
-    // AMS/filament refresh cadence, independent of telemetry dispatch so a steady
-    // stream of status updates can't starve it (ws_last_emit_ms is reset by those).
-    static constexpr uint64_t AMS_REFRESH_INTERVAL_MS = 10000;
-    std::atomic<uint64_t> ams_last_fetch_ms{0};
-
     // Throttling configuration for WebSocket updates
     // Critical changes (state transitions) dispatch immediately; telemetry is throttled
     static constexpr uint64_t STATUS_UPDATE_INTERVAL_MS = 1000;  // 1 update/sec for telemetry
@@ -347,13 +206,7 @@ private:
     // Connection thread management
     std::atomic<uint64_t>  connect_generation{0};
     std::thread            connect_thread;
-
-    void run_command_worker();
-    std::thread cmd_thread;
-    std::deque<std::function<void()>> cmd_queue;
-    std::mutex cmd_mutex;
-    std::condition_variable cmd_cv;
-    bool cmd_stop = false;
+    std::recursive_mutex   connect_mutex;
 };
 
 } // namespace Slic3r

src/slic3r/Utils/PresetUpdater.cpp

@@ -48,7 +48,6 @@
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/I18N.hpp"
 #include "slic3r/GUI/UpdateDialogs.hpp"
-#include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/Plater.hpp"
 #include "slic3r/GUI/format.hpp"
 #include "slic3r/GUI/NotificationManager.hpp"

src/slic3r/Utils/QidiPrinterAgent.cpp

@@ -2,24 +2,18 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
-#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
-#include <atomic>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/log/trivial.hpp>
 #include <cctype>
 #include "libslic3r/Preset.hpp"
-#include <cstddef>
-#include <exception>
 #include <map>
-#include <mutex>
 #include <sstream>
-#include <thread>
 #include <string>
 #include <utility>
 #include <vector>
@@ -40,26 +34,6 @@ bool has_visible_base_preset(const PresetCollection& filaments, const std::strin
     return false;
 }
 
-// RAII release of the in-flight fetch slot; movable so a failed thread start still releases it.
-struct InFlightGuard
-{
-    MoonrakerPrinterAgent* owner;
-    explicit InFlightGuard(MoonrakerPrinterAgent& o) noexcept : owner(&o) {}
-    InFlightGuard(InFlightGuard&& other) noexcept : owner(other.owner) { other.owner = nullptr; }
-    InFlightGuard(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(InFlightGuard&&) = delete;
-    ~InFlightGuard() { if (owner) owner->release_fetch_slot(); }
-};
-
-// nlohmann::json::value() returns the default only when the key is absent; a present but
-// null/wrong-typed value throws. Firmware JSON is untrusted, so read defensively.
-int read_int_or(const nlohmann::json& obj, const std::string& key, int fallback)
-{
-    auto it = obj.find(key);
-    return (it != obj.end() && it->is_number_integer()) ? it->get<int>() : fallback;
-}
-
 } // anonymous namespace
 
 const std::string QidiPrinterAgent_VERSION = "0.0.1";
@@ -73,166 +47,51 @@ AgentInfo QidiPrinterAgent::get_agent_info_static()
     return AgentInfo{"qidi", "Qidi", QidiPrinterAgent_VERSION, "Qidi printer agent"};
 }
 
-FilamentSyncMode QidiPrinterAgent::get_filament_sync_mode() const
+bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
-        return FilamentSyncMode::subscription;
-    return FilamentSyncMode::pull;
-}
+    std::string error;
 
-bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
-{
-    if (sync_mode != get_filament_sync_mode())
-        return false;
-
-    // Snapshot what the fetch needs; a reconnect can rewrite device_info meanwhile.
-    ConnectionSettings connection = get_connection_settings();
-    std::string        model_id;
-    std::string        model_name;
+    // 1. Fetch device info and infer series_id
+    std::string series_id;
     {
-        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
-        model_id   = device_info.model_id;
-        model_name = device_info.model_name;
-    }
-
-    // Reserve under the same mutex shutdown() uses, so the flag and the count can't race.
-    {
-        std::lock_guard<std::mutex> lock(fetch_lifecycle_mutex);
-        if (shutting_down.load())
-            return false;
-        if (filament_fetch_in_flight.load() > 0)
-            return true; // a fetch is already running; don't pile on
-        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
-    }
-
-    InFlightGuard guard{*this};
-    std::thread([this, guard = std::move(guard), connection = std::move(connection), model_id, model_name]() mutable {
-        try {
-            std::string error;
-
-            // 1. Fetch device info and infer series_id
-            std::string series_id;
-            {
-                MoonrakerDeviceInfo info;
-                if (fetch_device_info(connection, info, error)) {
-                    series_id = infer_series_id(info.model_id, info.dev_name);
-                }
-            }
-            if (series_id.empty()) {
-                // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
-                series_id = infer_series_id(model_id, model_name);
-            }
-
-            // 2. Fetch filament dictionary
-            QidiFilamentDict dict;
-            if (!fetch_filament_dict(connection, dict, error)) {
-                BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
-            }
-
-            // 3. Fetch slot info and build AmsTrayData directly
-            std::vector<AmsTrayData> trays;
-            int box_count = 0;
-            if (!fetch_slot_info(connection, dict, series_id, trays, box_count, error)) {
-                BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
-                return;
-            }
-
-            // 4. Build the AMS payload
-            build_ams_payload(box_count, box_count * 4 - 1, trays);
-        } catch (const std::exception& e) {
-            // why: an exception escaping a detached thread is std::terminate, and firmware
-            // JSON is untrusted; mirror run_command_worker and swallow it here.
-            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::fetch_filament_info: unhandled exception: " << e.what();
-        } catch (...) {
-            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::fetch_filament_info: unhandled exception";
+        MoonrakerDeviceInfo info;
+        if (fetch_device_info(device_info.base_url, device_info.api_key, info, error)) {
+            series_id = infer_series_id(info.model_id, info.dev_name);
         }
-    }).detach();
+    }
+    if (series_id.empty()) {
+        // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
+        series_id = infer_series_id(device_info.model_id, device_info.model_name);
+    }
+
+    // 2. Fetch filament dictionary
+    QidiFilamentDict dict;
+    if (!fetch_filament_dict(device_info.base_url, device_info.api_key, dict, error)) {
+        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
+    }
+
+    // 3. Fetch slot info and build AmsTrayData directly
+    std::vector<AmsTrayData> trays;
+    int                      box_count = 0;
+    if (!fetch_slot_info(device_info.base_url, device_info.api_key, dict, series_id, trays, box_count, error)) {
+        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
+        return false;
+    }
+
+    // 4. Build the AMS payload
+    build_ams_payload(box_count, box_count * 4 - 1, trays);
     return true;
 }
 
-bool QidiPrinterAgent::apply_box_mapping(const PrintParams& params) const
-{
-    // enable_box mirrors task_use_ams: engage the multi-color box only when this
-    // job actually routes filament through it. (See qidi-ams-findings.md §2/§8.3 —
-    // if firmware treats enable_box as "a box exists" rather than "use it this job",
-    // switch this gate to HasAms()/box_count instead.)
-    const int         enable = params.task_use_ams ? 1 : 0;
-    const std::string dev_id = get_connection_settings().dev_id;
-
-    // Build one gcode/script request instead of N blocking HTTP calls: apply_box_mapping
-    // runs on the caller's (GUI) thread before the print starts, so per-tool round trips
-    // would freeze the UI.
-    std::string script = "SAVE_VARIABLE VARIABLE=enable_box VALUE=" + std::to_string(enable);
-
-    // When the box isn't used this job, leave the existing value_t<tool> slot
-    // assignments untouched (enable_box=0 is enough to disengage it).
-    if (enable) {
-        if (params.ams_mapping.empty()) {
-            BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::apply_box_mapping: enable_box set but ams_mapping is empty";
-        } else {
-            // ams_mapping (v0) is a JSON array indexed by filament/tool; each value is the
-            // physical box slot (-1 = unmapped). Mirror it onto value_t<tool>.
-            auto mapping = nlohmann::json::parse(params.ams_mapping, nullptr, /*allow_exceptions*/ false);
-            if (mapping.is_discarded() || !mapping.is_array()) {
-                BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: invalid ams_mapping: " << params.ams_mapping;
-                return false;
-            }
-            for (size_t tool = 0; tool < mapping.size(); ++tool) {
-                if (!mapping[tool].is_number_integer())
-                    continue;
-                const int slot = mapping[tool].get<int>();
-                if (slot < 0)
-                    continue; // unmapped filament — skip
-                script += "\nSAVE_VARIABLE VARIABLE=value_t" + std::to_string(tool) +
-                          " VALUE=\"'slot" + std::to_string(slot) + "'\"";
-            }
-        }
-    }
-
-    if (!send_gcode(dev_id, script)) {
-        BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: failed to send box mapping";
-        return false;
-    }
-    return true;
-}
-
-int QidiPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
-{
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_local_print(std::move(params), update_fn, cancel_fn);
-}
-
-int QidiPrinterAgent::start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
-{
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_print(std::move(params), update_fn, cancel_fn, wait_fn);
-}
-
-int QidiPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
-{
-    // A failed box mapping is a send failure, not an upload failure.
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_local_print_with_record(std::move(params), update_fn, cancel_fn, wait_fn);
-}
-
-int QidiPrinterAgent::start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
-{
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_sdcard_print(std::move(params), update_fn, cancel_fn);
-}
-
-bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
+bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
+                                       const std::string&        api_key,
                                        const QidiFilamentDict&   dict,
                                        const std::string&        series_id,
                                        std::vector<AmsTrayData>& trays,
                                        int&                      box_count,
                                        std::string&              error)
 {
-    std::string url = join_url(connection.base_url, "/printer/objects/query?save_variables=variables");
+    std::string url = join_url(base_url, "/printer/objects/query?save_variables=variables");
     for (int i = 0; i < 16; ++i) {
         url += "&box_stepper%20slot" + std::to_string(i) + "=runout_button";
     }
@@ -242,9 +101,8 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
     std::string http_error;
 
     auto http = Http::get(url);
-    configure_http(http, connection);
-    if (!connection.api_key.empty()) {
-        http.header("X-Api-Key", connection.api_key);
+    if (!api_key.empty()) {
+        http.header("X-Api-Key", api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)
@@ -269,12 +127,22 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         return false;
     }
 
-    nlohmann::json status;
-    nlohmann::json variables;
-    if (!parse_slot_response(response_body, status, variables, error))
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    if (json.is_discarded()) {
+        error = "Invalid JSON response";
         return false;
+    }
 
-    box_count = read_int_or(variables, "box_count", 1);
+    if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("save_variables") ||
+        !json["result"]["status"]["save_variables"].contains("variables")) {
+        error = "Unexpected JSON structure";
+        return false;
+    }
+
+    auto& variables = json["result"]["status"]["save_variables"]["variables"];
+    auto& status    = json["result"]["status"];
+
+    box_count = variables.value("box_count", 1);
     if (box_count < 0) {
         box_count = 0;
     }
@@ -297,9 +165,9 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         tray.slot_index = i;
 
         // Read slot variables
-        const int color_index     = read_int_or(variables, "color_slot" + std::to_string(i), 1);
-        const int filament_type   = read_int_or(variables, "filament_slot" + std::to_string(i), 1);
-        const int vendor_type     = read_int_or(variables, "vendor_slot" + std::to_string(i), 0);
+        const int color_index     = variables.value("color_slot" + std::to_string(i), 1);
+        const int filament_type   = variables.value("filament_slot" + std::to_string(i), 1);
+        const int vendor_type     = variables.value("vendor_slot" + std::to_string(i), 0);
 
         // Check filament presence via runout sensor
         std::string box_stepper_key = "box_stepper slot" + std::to_string(i);
@@ -307,7 +175,7 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         if (status.contains(box_stepper_key)) {
             auto& box_stepper = status[box_stepper_key];
             if (box_stepper.contains("runout_button") && !box_stepper["runout_button"].is_null()) {
-                const int runout_button = read_int_or(box_stepper, "runout_button", 0);
+                int runout_button = box_stepper["runout_button"].template get<int>();
                 tray.has_filament = (runout_button == 0);
             }
         }
@@ -347,45 +215,20 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
     return true;
 }
 
-bool QidiPrinterAgent::parse_slot_response(const std::string& response_body,
-                                           nlohmann::json&    status,
-                                           nlohmann::json&    variables,
-                                           std::string&       error)
-{
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-    if (json.is_discarded()) {
-        error = "Invalid JSON response";
-        return false;
-    }
-
-    if (!json.is_object() || !json.contains("result") || !json["result"].is_object() || !json["result"].contains("status") ||
-        !json["result"]["status"].is_object() || !json["result"]["status"].contains("save_variables") ||
-        !json["result"]["status"]["save_variables"].is_object() || !json["result"]["status"]["save_variables"].contains("variables") ||
-        !json["result"]["status"]["save_variables"]["variables"].is_object()) {
-        // why: Qidi firmware may send null here, but json::value() throws for it.
-        error = "Unexpected JSON structure: save_variables.variables must be an object";
-        return false;
-    }
-
-    status    = json["result"]["status"];
-    variables = status["save_variables"]["variables"];
-    return true;
-}
-
-bool QidiPrinterAgent::fetch_filament_dict(const ConnectionSettings& connection,
+bool QidiPrinterAgent::fetch_filament_dict(const std::string& base_url,
+                                           const std::string& api_key,
                                            QidiFilamentDict& dict,
                                            std::string& error) const
 {
-    std::string url = join_url(connection.base_url, "/server/files/config/officiall_filas_list.cfg");
+    std::string url = join_url(base_url, "/server/files/config/officiall_filas_list.cfg");
 
     std::string response_body;
     bool        success = false;
     std::string http_error;
 
     auto http = Http::get(url);
-    configure_http(http, connection);
-    if (!connection.api_key.empty()) {
-        http.header("X-Api-Key", connection.api_key);
+    if (!api_key.empty()) {
+        http.header("X-Api-Key", api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)

src/slic3r/Utils/QidiPrinterAgent.hpp

@@ -3,8 +3,6 @@
 
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
-#include "bambu_networking.hpp"
-#include "nlohmann/json_fwd.hpp"
 
 #include <map>
 #include <string>
@@ -16,7 +14,7 @@ class QidiPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit QidiPrinterAgent(std::string log_dir);
-    ~QidiPrinterAgent() override { shutdown(); }
+    ~QidiPrinterAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
@@ -24,23 +22,7 @@ public:
     // Override filament sync (Qidi-specific implementation)
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
-    static bool parse_slot_response(const std::string& response_body,
-                                    nlohmann::json&    status,
-                                    nlohmann::json&    variables,
-                                    std::string&       error);
-
-    // Print operations — emit QiDi multi-color box config, then delegate to base.
-    int start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
-    int start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
-    int start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
-    int start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
-
-    FilamentSyncMode get_filament_sync_mode() const override;
-
 private:
-    // Push enable_box + value_t<tool> SAVE_VARIABLEs before a print starts.
-    // Returns false if any command fails (caller should abort the print).
-    bool apply_box_mapping(const PrintParams& params) const;
     struct QidiFilamentDict
     {
         std::map<int, std::string> colors;
@@ -48,13 +30,14 @@ private:
     };
 
     // Qidi-specific methods
-    bool fetch_slot_info(const ConnectionSettings& connection,
+    bool fetch_slot_info(const std::string&        base_url,
+                         const std::string&        api_key,
                          const QidiFilamentDict&   dict,
                          const std::string&        series_id,
                          std::vector<AmsTrayData>& trays,
                          int&                      box_count,
                          std::string&              error);
-    bool fetch_filament_dict(const ConnectionSettings& connection, QidiFilamentDict& dict, std::string& error) const;
+    bool fetch_filament_dict(const std::string& base_url, const std::string& api_key, QidiFilamentDict& dict, std::string& error) const;
     std::string normalize_filament_type(const std::string& filament_type);
     std::string infer_series_id(const std::string& model_id, const std::string& dev_name);
     std::string normalize_model_key(std::string value);

src/slic3r/Utils/SnapmakerPrinterAgent.cpp

@@ -2,19 +2,11 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
-#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
-#include <atomic>
 #include <boost/log/trivial.hpp>
-#include <chrono>
-#include <cstdint>
-#include <exception>
-#include <mutex>
-#include <sstream>
-#include <thread>
 #include <vector>
 #include <string>
 #include "libslic3r/Preset.hpp"
@@ -26,77 +18,6 @@ namespace Slic3r {
 namespace {
 
 constexpr const char* SNAPMAKER_AGENT_VERSION = "0.0.1";
-constexpr int64_t     CAMERA_REFRESH_INTERVAL_MS = 300'000;
-
-int64_t now_ms()
-{
-    return std::chrono::duration_cast<std::chrono::milliseconds>(
-        std::chrono::steady_clock::now().time_since_epoch()).count();
-}
-
-// RAII release of the in-flight fetch slot; movable so a failed thread start still releases it.
-struct InFlightGuard
-{
-    MoonrakerPrinterAgent* owner;
-    explicit InFlightGuard(MoonrakerPrinterAgent& o) noexcept : owner(&o) {}
-    InFlightGuard(InFlightGuard&& other) noexcept : owner(other.owner) { other.owner = nullptr; }
-    InFlightGuard(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(InFlightGuard&&) = delete;
-    ~InFlightGuard() { if (owner) owner->release_fetch_slot(); }
-};
-
-// nlohmann::json::value() returns the default only when the key is absent; a present but
-// null/wrong-typed value throws. Firmware JSON is untrusted, so read defensively.
-int read_int_or(const nlohmann::json& obj, const char* key, int fallback)
-{
-    auto it = obj.find(key);
-    return (it != obj.end() && it->is_number_integer()) ? it->get<int>() : fallback;
-}
-
-std::vector<std::string> read_string_array_or(const nlohmann::json& obj, const char* key)
-{
-    auto it = obj.find(key);
-    if (it == obj.end() || !it->is_array())
-        return {};
-    std::vector<std::string> out;
-    out.reserve(it->size());
-    for (const auto& v : *it)
-        out.push_back(v.is_string() ? v.get<std::string>() : std::string{});
-    return out;
-}
-
-std::vector<bool> read_bool_array_or(const nlohmann::json& obj, const char* key)
-{
-    auto it = obj.find(key);
-    if (it == obj.end() || !it->is_array())
-        return {};
-    std::vector<bool> out;
-    out.reserve(it->size());
-    for (const auto& v : *it)
-        out.push_back(v.is_boolean() ? v.get<bool>() : false);
-    return out;
-}
-
-// Parse a hex colour, stopping at the first non-hex character. std::stoul throws on
-// empty/non-hex input, which must not escape the detached fetch thread.
-unsigned int parse_hex_color(const std::string& hex)
-{
-    unsigned int value = 0;
-    for (char c : hex) {
-        int digit;
-        if (c >= '0' && c <= '9')
-            digit = c - '0';
-        else if (c >= 'a' && c <= 'f')
-            digit = c - 'a' + 10;
-        else if (c >= 'A' && c <= 'F')
-            digit = c - 'A' + 10;
-        else
-            break;
-        value = (value << 4) | static_cast<unsigned int>(digit);
-    }
-    return value;
-}
 
 // Safely access a parallel array by index, returning a fallback if out of bounds.
 template<typename T>
@@ -119,16 +40,14 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
             filaments.get_preset_base(p) == &p && p.config.opt_string("filament_vendor", 0u) == vendor_name &&
             p.config.opt_string("filament_type", 0u) == filament_type) {
             // The printer returns RGBA in the format RRGGBBAA, but profiles store color as #RRGGBB,
-            // so we must remove # and ignore alpha channel for distance calculation. Firmware
-            // colours are untrusted; parse_hex_color tolerates empty/non-hex instead of throwing.
-            unsigned int target_color_value =
-                parse_hex_color(color_rgba.substr(0, color_rgba.size() >= 2 ? color_rgba.size() - 2 : 0));
+            // so we must remove # and ignore alpha channel for distance calculation
+            unsigned int target_color_value = std::stoul(color_rgba.substr(0, color_rgba.length() - 2), nullptr, 16);
 
             std::string  p_color = p.config.opt_string("default_filament_colour", 0u);
-            unsigned int p_color_value = 0;
+            unsigned int p_color_value;
             if (!p_color.empty()) {
-                size_t hash_pos = p_color.find("#");
-                p_color_value   = parse_hex_color(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0));
+                size_t       hash_pos = p_color.find("#");
+                p_color_value         = std::stoul(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0), nullptr, 16);
             } else {
                 // Default to black if no color specified in profile. Assume other profiles might be a closer color match.
                 // Could be a problem if the target color is also black and there exist a specific profile for that type, vendor and color
@@ -155,31 +74,6 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
 
 SnapmakerPrinterAgent::SnapmakerPrinterAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
 
-void SnapmakerPrinterAgent::start_camera_monitor()
-{
-    enqueue_command([this] {
-        send_ws_rpc("camera.start_monitor",
-                    {{"domain", "lan"}, {"interval", 0}, {"expect_pw", false}});
-    });
-    m_camera_last_fire_ms.store(now_ms());
-}
-
-void SnapmakerPrinterAgent::on_status_loop_tick(const std::string& dev_id)
-{
-    (void) dev_id;
-    const int64_t last = m_camera_last_fire_ms.load();
-    if (last == 0 || now_ms() - last >= CAMERA_REFRESH_INTERVAL_MS) {
-        start_camera_monitor();
-    }
-}
-
-int SnapmakerPrinterAgent::command_start_camera(std::string dev_id)
-{
-    (void) dev_id;
-    start_camera_monitor();
-    return BAMBU_NETWORK_SUCCESS;
-}
-
 AgentInfo SnapmakerPrinterAgent::get_agent_info_static()
 {
     return AgentInfo{"snapmaker", "Snapmaker", SNAPMAKER_AGENT_VERSION, "Snapmaker printer agent"};
@@ -215,170 +109,127 @@ std::string SnapmakerPrinterAgent::combine_filament_type(const std::string& type
     return base;
 }
 
-bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    (void) dev_id;
-    if (sync_mode != get_filament_sync_mode())
+    std::string url = join_url(device_info.base_url, "/printer/objects/query?print_task_config&filament_detect");
+
+    std::string response_body;
+    bool        success = false;
+    std::string http_error;
+
+    auto http = Http::get(url);
+    if (!device_info.api_key.empty()) {
+        http.header("X-Api-Key", device_info.api_key);
+    }
+    http.timeout_connect(5)
+        .timeout_max(10)
+        .on_complete([&](std::string body, unsigned status) {
+            if (status == 200) {
+                response_body = body;
+                success       = true;
+            } else {
+                http_error = "HTTP error: " + std::to_string(status);
+            }
+        })
+        .on_error([&](std::string body, std::string err, unsigned status) {
+            http_error = err;
+            if (status > 0) {
+                http_error += " (HTTP " + std::to_string(status) + ")";
+            }
+        })
+        .perform_sync();
+
+    if (!success) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
         return false;
-
-    // Snapshot everything the fetch needs (URL, api key, TLS/CA): a reconnect can rewrite
-    // device_info meanwhile.
-    const ConnectionSettings connection = get_connection_settings();
-
-    // Reserve under the same mutex shutdown() uses, so the flag and the count can't race.
-    {
-        std::lock_guard<std::mutex> lock(fetch_lifecycle_mutex);
-        if (shutting_down.load())
-            return false;
-        if (filament_fetch_in_flight.load() > 0)
-            return true; // a fetch is already running; don't pile on
-        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
     }
 
-    InFlightGuard guard{*this};
-    std::thread([this, guard = std::move(guard), connection]() {
-        try {
-            const std::string url = join_url(connection.base_url, "/printer/objects/query?print_task_config&filament_detect");
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    if (json.is_discarded()) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
+        return false;
+    }
 
-            std::string response_body;
-            bool success = false;
-            std::string http_error;
+    // Navigate to result.status.print_task_config
+    if (!json.contains("result") || !json["result"].contains("status") ||
+        !json["result"]["status"].contains("print_task_config")) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
+        return false;
+    }
 
-            auto http = Http::get(url);
-            configure_http(http, connection);
-            if (!connection.api_key.empty()) {
-                http.header("X-Api-Key", connection.api_key);
-            }
-            http.timeout_connect(5)
-                .timeout_max(10)
-                .on_complete([&](std::string body, unsigned status) {
-                    if (status == 200) {
-                        response_body = body;
-                        success       = true;
-                    } else {
-                        http_error = "HTTP error: " + std::to_string(status);
-                    }
-                })
-                .on_error([&](std::string body, std::string err, unsigned status) {
-                    http_error = err;
-                    if (status > 0) {
-                        http_error += " (HTTP " + std::to_string(status) + ")";
-                    }
-                })
-                .perform_sync();
+    auto& ptc = json["result"]["status"]["print_task_config"];
 
-            if (!success) {
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
-                return;
-            }
+    // Read parallel arrays from print_task_config
+    auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
+    auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
+    auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
+    auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
+    auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
 
-            auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-            if (json.is_discarded()) {
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
-                return;
-            }
+    const int slot_count = static_cast<int>(filament_exist.size());
+    if (slot_count == 0) {
+        BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
+        return false;
+    }
 
-            // Navigate to result.status.print_task_config
-            if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("print_task_config")) {
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
-                return;
-            }
+    // Read NFC filament_detect data for temperature info (optional)
+    nlohmann::json nfc_info;
+    if (json["result"]["status"].contains("filament_detect") &&
+        json["result"]["status"]["filament_detect"].contains("info")) {
+        nfc_info = json["result"]["status"]["filament_detect"]["info"];
+    }
 
-            auto& ptc = json["result"]["status"]["print_task_config"];
+    static const std::string empty_str;
+    static const std::string default_color = "FFFFFFFF";
 
-            // Read parallel arrays from print_task_config
-            auto filament_exist    = read_bool_array_or(ptc, "filament_exist");
-            auto filament_type     = read_string_array_or(ptc, "filament_type");
-            auto filament_sub_type = read_string_array_or(ptc, "filament_sub_type");
-            auto filament_color    = read_string_array_or(ptc, "filament_color_rgba");
-            auto filament_vendor   = read_string_array_or(ptc, "filament_vendor");
+    std::vector<AmsTrayData> trays;
+    trays.reserve(slot_count);
 
-            const int slot_count = static_cast<int>(filament_exist.size());
-            if (slot_count == 0) {
-                BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
-                return;
-            }
+    for (int i = 0; i < slot_count; ++i) {
+        AmsTrayData tray;
+        tray.slot_index   = i;
+        tray.has_filament = filament_exist[i];
 
-            // Read NFC filament_detect data for temperature info (optional)
-            nlohmann::json nfc_info;
-            if (json["result"]["status"].contains("filament_detect") && json["result"]["status"]["filament_detect"].contains("info")) {
-                nfc_info = json["result"]["status"]["filament_detect"]["info"];
-            }
+        if (tray.has_filament) {
+            tray.tray_type     = combine_filament_type(safe_at(filament_type, i, empty_str),
+                                                       safe_at(filament_sub_type, i, empty_str));
+            tray.tray_color    = safe_at(filament_color, i, default_color);
 
-            static const std::string empty_str;
-            static const std::string default_color = "FFFFFFFF";
+            auto* bundle = GUI::wxGetApp().preset_bundle;
+            // Try to find a matching preset for this filament based on vendor, type and color.
+            // If not found, default to traditional search by type only or generic type mapping.
+            if (bundle) {
+                std::string vendor      = safe_at(filament_vendor, i, empty_str);
+                std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
+                                                                                       tray.tray_color);
 
-            std::vector<AmsTrayData> trays;
-            trays.reserve(slot_count);
-
-            for (int i = 0; i < slot_count; ++i) {
-                AmsTrayData tray;
-                tray.slot_index   = i;
-                tray.has_filament = filament_exist[i];
-
-                if (tray.has_filament) {
-                    tray.tray_type  = combine_filament_type(safe_at(filament_type, i, empty_str), safe_at(filament_sub_type, i, empty_str));
-                    tray.tray_color = safe_at(filament_color, i, default_color);
-
-                    auto* bundle = GUI::wxGetApp().preset_bundle;
-                    // Try to find a matching preset for this filament based on vendor, type and color.
-                    // If not found, default to traditional search by type only or generic type mapping.
-                    if (bundle) {
-                        std::string vendor      = safe_at(filament_vendor, i, empty_str);
-                        std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
-                                                                                               tray.tray_color);
-
-                        if (!filament_id.empty()) {
-                            tray.tray_info_idx = filament_id;
-                            BOOST_LOG_TRIVIAL(warning)
-                                << "Filament sync: Found manufacturer-specific profile for slot " << i << ": " << filament_id;
-                        } else {
-                            tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
-                        }
-                    } else {
-                        tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
-                    }
-
-                    // Extract NFC temperature data if available
-                    if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
-                        auto&       nfc_slot = nfc_info[i];
-                        std::string vendor   = "NONE";
-                        if (auto vendor_it = nfc_slot.find("VENDOR"); vendor_it != nfc_slot.end() && vendor_it->is_string()) {
-                            vendor = vendor_it->get<std::string>();
-                        }
-                        if (vendor != "NONE" && !vendor.empty()) {
-                            tray.bed_temp    = read_int_or(nfc_slot, "BED_TEMP", 0);
-                            tray.nozzle_temp = read_int_or(nfc_slot, "FIRST_LAYER_TEMP", 0);
-                        }
-                    }
+                if (!filament_id.empty()) {
+                    tray.tray_info_idx = filament_id;
+                    BOOST_LOG_TRIVIAL(warning) << "Filament sync: Found manufacturer-specific profile for slot " << i << ": "
+                                               << filament_id;
+                } else {
+                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
                 }
-
-                trays.emplace_back(std::move(tray));
+            } else {
+                tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
             }
 
-            build_ams_payload(1, slot_count - 1, trays);
-        } catch (const std::exception& e) {
-            // why: an exception escaping a detached thread is std::terminate, and firmware
-            // JSON is untrusted; mirror run_command_worker and swallow it here.
-            BOOST_LOG_TRIVIAL(error) << "SnapmakerPrinterAgent::fetch_filament_info: unhandled exception: " << e.what();
-        } catch (...) {
-            BOOST_LOG_TRIVIAL(error) << "SnapmakerPrinterAgent::fetch_filament_info: unhandled exception";
+            // Extract NFC temperature data if available
+            if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
+                auto& nfc_slot = nfc_info[i];
+                std::string vendor = nfc_slot.value("VENDOR", "NONE");
+                if (vendor != "NONE" && !vendor.empty()) {
+                    tray.bed_temp    = nfc_slot.value("BED_TEMP", 0);
+                    tray.nozzle_temp = nfc_slot.value("FIRST_LAYER_TEMP", 0);
+                }
+            }
         }
-    }).detach();
 
+        trays.emplace_back(std::move(tray));
+    }
+
+    build_ams_payload(1, slot_count - 1, trays);
     return true;
 }
 
-std::string SnapmakerPrinterAgent::get_camera_url() const
-{
-    return get_connection_settings().base_url + "/server/files/camera/monitor.jpg";
-}
-
-FilamentSyncMode SnapmakerPrinterAgent::get_filament_sync_mode() const
-{
-    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
-        return FilamentSyncMode::subscription;
-    return FilamentSyncMode::pull;
-}
-
 } // namespace Slic3r

src/slic3r/Utils/SnapmakerPrinterAgent.hpp

@@ -3,8 +3,6 @@
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 
-#include <atomic>
-#include <cstdint>
 #include <string>
 
 namespace Slic3r {
@@ -13,25 +11,16 @@ class SnapmakerPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit SnapmakerPrinterAgent(std::string log_dir);
-    ~SnapmakerPrinterAgent() override { shutdown(); }
+    ~SnapmakerPrinterAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
-    FilamentSyncMode get_filament_sync_mode() const override;
-    int command_start_camera(std::string dev_id) override;
-    CameraStreamMode get_camera_stream_mode() const override { return CameraStreamMode::http_snapshot; }
-    std::string get_camera_url() const override;
 
 private:
     // Combine filament_type + filament_sub_type into a unified type string
     static std::string combine_filament_type(const std::string& type, const std::string& sub_type);
-
-    void start_camera_monitor();
-    void on_status_loop_tick(const std::string& dev_id) override;
-
-    std::atomic<int64_t> m_camera_last_fire_ms{0};
 };
 
 } // namespace Slic3r

tests/libslic3r/test_preset_bundle_loading.cpp

@@ -24,7 +24,6 @@
 
 #include "test_utils.hpp"
 
-#include <algorithm>
 #include <iostream>
 #include <initializer_list>
 #include <vector>

tests/slic3rutils/CMakeLists.txt

@@ -25,7 +25,6 @@ add_executable(${_TEST_NAME}_tests
     test_plugin_capabilities_in_use.cpp
     test_plugin_status.cpp
     test_printer_agent.cpp
-    test_qidi_printer_agent.cpp
     test_plugin_install.cpp
     test_plugin_lifecycle.cpp
     test_plugin_printer_agent.cpp

tests/slic3rutils/test_printer_agent.cpp

@@ -1,29 +1,18 @@
 #include <catch2/catch_all.hpp>
 
-#include <functional>
-#include <slic3r/Utils/BBLPrinterAgent.hpp>
-#include <slic3r/Utils/IPrinterAgent.hpp>
-#include <slic3r/Utils/MoonrakerPrinterAgent.hpp>
 #include <memory>
 #include <slic3r/Utils/NetworkAgentFactory.hpp>
 
 #include <catch2/catch_test_macros.hpp>
 #include <pybind11/pytypes.h>
 #include <catch2/catch_message.hpp>
-#include "catch2/catch_approx.hpp"
 #include "python_test_support.hpp"
 
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>
 
-#include <atomic>
-#include <chrono>
-#include <future>
-#include <slic3r/Utils/bambu_networking.hpp>
 #include <string>
-#include <thread>
 #include <pybind11/cast.h>
-#include <utility>
 
 namespace Slic3r { class ICloudServiceAgent; }
 namespace Slic3r { class IPrinterAgent; }
@@ -31,379 +20,6 @@ namespace Slic3r { class IPrinterAgent; }
 using namespace Slic3r;
 namespace py = pybind11;
 
-namespace {
-
-// Releases a promise on scope exit, so a throwing REQUIRE cannot leave a parked detached
-// thread (and any destructor that joins it) blocked forever.
-class ScopedPromiseRelease
-{
-public:
-    explicit ScopedPromiseRelease(std::shared_ptr<std::promise<void>> p) : m_p(std::move(p)) {}
-    ~ScopedPromiseRelease()
-    {
-        if (m_p) {
-            try {
-                m_p->set_value();
-            } catch (...) {
-                // promise already satisfied
-            }
-        }
-    }
-    ScopedPromiseRelease(const ScopedPromiseRelease&) = delete;
-    ScopedPromiseRelease& operator=(const ScopedPromiseRelease&) = delete;
-
-private:
-    std::shared_ptr<std::promise<void>> m_p;
-};
-
-} // namespace
-
-class MoonrakerParserProbe : public MoonrakerPrinterAgent
-{
-public:
-    using MoonrakerPrinterAgent::parse_nozzle_diameter;
-
-    explicit MoonrakerParserProbe(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-};
-
-TEST_CASE("Moonraker parses nozzle diameter from configfile settings", "[unit][moonraker]")
-{
-    const auto response = nlohmann::json::parse(R"({
-        "result": {
-            "status": {
-                "configfile": {
-                    "settings": {
-                        "extruder": {
-                            "nozzle_diameter": 0.6
-                        }
-                    }
-                }
-            }
-        }
-    })");
-
-    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(response) == Catch::Approx(0.6f));
-}
-
-TEST_CASE("Moonraker parses nozzle diameter from raw config and tolerates missing data", "[unit][moonraker]")
-{
-    const auto raw_config_response = nlohmann::json::parse(R"({
-        "result": {
-            "status": {
-                "configfile": {
-                    "config": {
-                        "extruder": {
-                            "nozzle_diameter": "0.8"
-                        }
-                    }
-                }
-            }
-        }
-    })");
-    const auto missing_response = nlohmann::json::object();
-
-    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(raw_config_response) == Catch::Approx(0.8f));
-    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(missing_response) == 0.0f);
-}
-
-// why: an agent without a Bambu-dialect translation must refuse these commands before any network or wx path.
-TEST_CASE("unit: default AMS commands report not supported", "[unit][moonraker]")
-{
-    MoonrakerPrinterAgent agent("");
-
-    CHECK(agent.command_ams_refresh_rfid("dev", 123, 1, 0, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.command_ams_calibrate("dev", 1, 2, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.command_ams_select_tray("dev", "123", 3, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-}
-
-TEST_CASE("unit: Moonraker light name matching", "[unit][moonraker]")
-{
-    CHECK(moonraker_is_light_name("caselight"));
-    CHECK(moonraker_is_light_name("LED_STRIP"));
-    CHECK_FALSE(moonraker_is_light_name("beeper"));
-    CHECK(moonraker_is_light_name("FLASHLIGHT_SWITCH"));
-    CHECK(moonraker_is_light_name("MODLELIGHT_SWITCH"));
-}
-
-TEST_CASE("Moonraker webcam selection skips disabled webcams and prefers the first enabled one",
-          "[unit][moonraker]")
-{
-    const auto response = nlohmann::json::parse(R"({
-        "result": { "webcams": [
-            { "name": "disabled", "enabled": false, "stream_url": "http://192.168.1.9:8080/stream" },
-            { "name": "enabled",  "enabled": true,  "stream_url": "http://192.168.1.9:8080/stream" }
-        ]}
-    })");
-
-    MoonrakerWebcamSelection selection;
-    REQUIRE(moonraker_parse_webcam_list(response, "http://192.168.1.9:7125", selection));
-    CHECK(selection.name == "enabled");
-    CHECK(selection.url == "http://192.168.1.9:8080/stream");
-    CHECK(selection.mode == CameraStreamMode::http);
-    CHECK(selection.error.empty());
-}
-
-TEST_CASE("Moonraker webcam selection resolves relative URLs, maps rtsp, and rejects other schemes",
-          "[unit][moonraker]")
-{
-    const auto relative = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "cam", "snapshot_url": "/webcam/?action=snapshot" } ] }
-    })");
-    MoonrakerWebcamSelection rel;
-    REQUIRE(moonraker_parse_webcam_list(relative, "http://192.168.1.9:7125", rel));
-    // Relative URLs use the printer web root, without the Moonraker API port.
-    CHECK(rel.url == "http://192.168.1.9/webcam/?action=snapshot");
-    CHECK(rel.mode == CameraStreamMode::http_snapshot);
-
-    const auto rtsp = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "cam", "stream_url": "rtsp://192.168.1.9:554/live" } ] }
-    })");
-    MoonrakerWebcamSelection rt;
-    REQUIRE(moonraker_parse_webcam_list(rtsp, "http://192.168.1.9:7125", rt));
-    CHECK(rt.mode == CameraStreamMode::rtsp);
-
-    const auto unsupported = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "cam", "stream_url": "weird://host/x" } ] }
-    })");
-    MoonrakerWebcamSelection bad;
-    CHECK_FALSE(moonraker_parse_webcam_list(unsupported, "http://192.168.1.9:7125", bad));
-    CHECK(bad.error == "Unsupported webcam URL");
-}
-
-TEST_CASE("Moonraker webcam selection reports no webcam and malformed structure", "[unit][moonraker]")
-{
-    const auto empty = nlohmann::json::parse(R"({ "result": { "webcams": [] } })");
-    MoonrakerWebcamSelection none;
-    CHECK_FALSE(moonraker_parse_webcam_list(empty, "http://host:7125", none));
-    CHECK(none.error == "No enabled webcam");
-
-    const auto disabled_only = nlohmann::json::parse(R"({
-        "result": { "webcams": [ { "name": "disabled", "enabled": false, "stream_url": "http://host/stream" } ] }
-    })");
-    MoonrakerWebcamSelection off;
-    CHECK_FALSE(moonraker_parse_webcam_list(disabled_only, "http://host:7125", off));
-
-    const auto malformed = nlohmann::json::parse(R"({ "result": { "nope": 1 } })");
-    MoonrakerWebcamSelection shape;
-    CHECK_FALSE(moonraker_parse_webcam_list(malformed, "http://host:7125", shape));
-    CHECK(shape.error == "Unexpected JSON structure");
-}
-
-// ===========================================================================
-// UNIT - handle_request's not-supported default.
-// The agent is the only thing that knows what it can translate, so an untranslated
-// command has to say so instead of returning success and letting the UI believe the
-// control worked. Guards the inverse too: the pushing namespace is genuinely
-// satisfied by the websocket status stream, and it re-fires from the keepalive timer
-// roughly once a second, so it must stay a success or it would raise a dialog on a
-// timer. Only branches that touch neither the network nor wx are exercised.
-// ===========================================================================
-TEST_CASE("unit: Moonraker reports untranslated commands as not supported", "[unit][moonraker]")
-{
-    MoonrakerPrinterAgent agent("");
-
-    CHECK(agent.send_message("dev", R"({"print":{"command":"ams_change_filament"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.send_message("dev", R"({"system":{"command":"set_door_stat"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.send_message("dev", R"({"xcam":{"command":"xcam_control_set"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-
-    CHECK(agent.send_message("dev", R"({"pushing":{"command":"pushall"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
-    CHECK(agent.send_message("dev", R"({"pushing":{"command":"start"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
-
-    // why: malformed input is a different failure than an untranslated command, and the
-    // default must not swallow it into a misleading not-supported verdict.
-    CHECK(agent.send_message("dev", "{not json", 0, 0) == BAMBU_NETWORK_ERR_INVALID_RESULT);
-}
-
-// why: IPrinterAgent::fetch_filament_info is the single virtual hook derived agents override
-// (MoonrakerPrinterAgent's own override is synchronous, but QidiPrinterAgent's override is
-// fire-and-forget: it spawns a detached thread and returns immediately). QidiPrinterAgent is
-// `final`, so this probes the same contract with a controllable double instead.
-TEST_CASE("unit: a fire-and-forget override of fetch_filament_info is not waited on by the caller",
-          "[unit][moonraker]")
-{
-    class RecordingAgent : public Slic3r::MoonrakerPrinterAgent
-    {
-    public:
-        explicit RecordingAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-
-        // Shared so the detached proxy fetch never touches `this`: a throwing REQUIRE
-        // then cannot leave it dereferencing a destroyed agent.
-        std::shared_ptr<std::atomic<bool>>  invoked{std::make_shared<std::atomic<bool>>(false)};
-        std::shared_ptr<std::promise<void>> release_gate{std::make_shared<std::promise<void>>()};
-        std::shared_ptr<std::promise<void>> done_promise{std::make_shared<std::promise<void>>()};
-
-        bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode /*sync_mode*/ = FilamentSyncMode::pull) override
-        {
-            auto invoked_p      = invoked;
-            auto release_gate_p = release_gate;
-            auto done_promise_p = done_promise;
-            std::thread([invoked_p, release_gate_p, done_promise_p]() {
-                invoked_p->store(true);
-                // Block here until the test explicitly releases us, proving the caller
-                // (fetch_filament_info) does not wait for this to run.
-                release_gate_p->get_future().wait();
-                done_promise_p->set_value();
-            }).detach();
-            return true;
-        }
-    };
-
-    auto agent = std::make_shared<RecordingAgent>(std::string{});
-    auto done_future = agent->done_promise->get_future();
-    ScopedPromiseRelease release_gate_guard{agent->release_gate};
-
-    bool immediate_result = agent->fetch_filament_info("test-dev");
-
-    // fetch_filament_info must return before its background work completes — prove
-    // it by confirming the background call is still blocked on the gate right now.
-    REQUIRE(immediate_result == true);
-    REQUIRE(done_future.wait_for(std::chrono::milliseconds(100)) == std::future_status::timeout);
-
-    // Now let the background call finish and confirm it actually ran (polymorphic dispatch).
-    agent->release_gate->set_value();
-    REQUIRE(done_future.wait_for(std::chrono::seconds(2)) == std::future_status::ready);
-    REQUIRE(agent->invoked->load() == true);
-}
-
-namespace {
-
-// Globals so a parked proxy fetch thread never dereferences a freed agent.
-std::atomic<int>  g_deferred_fetch_running{0};
-std::atomic<bool> g_deferred_destroy_returned{false};
-
-// Releases the given gates, then joins on scope exit: so a throwing REQUIRE cannot leave
-// the thread blocked (deadlocking the join) or let it std::terminate.
-class ScopedJoiner
-{
-public:
-    ScopedJoiner(std::thread& t, std::shared_ptr<std::promise<void>> gate1, std::shared_ptr<std::promise<void>> gate2)
-        : m_thread(t), m_gates{std::move(gate1), std::move(gate2)}
-    {}
-    ~ScopedJoiner()
-    {
-        for (auto& gate : m_gates) {
-            if (gate) {
-                try {
-                    gate->set_value();
-                } catch (...) {
-                    // promise already satisfied
-                }
-            }
-        }
-        if (m_thread.joinable()) m_thread.join();
-    }
-    ScopedJoiner(const ScopedJoiner&) = delete;
-    ScopedJoiner& operator=(const ScopedJoiner&) = delete;
-
-private:
-    std::thread&                        m_thread;
-    std::shared_ptr<std::promise<void>> m_gates[2];
-};
-
-// A fetch that parks before touching the in-flight counter, so teardown's wait can
-// observe zero first.
-class DeferredFetchAgent : public MoonrakerPrinterAgent
-{
-public:
-    explicit DeferredFetchAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-
-    // Shared so a parked proxy fetch can never outlive the stack that owns it.
-    std::shared_ptr<std::promise<void>> entered{std::make_shared<std::promise<void>>()};
-    std::shared_ptr<std::promise<void>> allow_fetch{std::make_shared<std::promise<void>>()};
-    std::shared_ptr<std::promise<void>> allow_finish{std::make_shared<std::promise<void>>()};
-    std::shared_ptr<std::promise<void>> running{std::make_shared<std::promise<void>>()};
-
-    // Runs the callable on the command worker, which teardown joins.
-    void post(std::function<void()> fn) { enqueue_command(std::move(fn)); }
-
-    bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode /*sync_mode*/ = FilamentSyncMode::pull) override
-    {
-        // Resumes after ~DeferredFetchAgent destroyed these members; snapshot up front.
-        auto entered_p      = entered;
-        auto allow_fetch_p  = allow_fetch;
-        auto allow_finish_p = allow_finish;
-        auto running_p      = running;
-
-        entered_p->set_value();
-        allow_fetch_p->get_future().wait();
-
-        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
-        std::thread([this, finish = std::move(allow_finish_p), running = std::move(running_p)] {
-            struct InFlightGuard
-            {
-                MoonrakerPrinterAgent& owner;
-                ~InFlightGuard() { owner.release_fetch_slot(); }
-            } guard{*this};
-
-            g_deferred_fetch_running.fetch_add(1, std::memory_order_relaxed);
-            running->set_value();
-            finish->get_future().wait();
-            g_deferred_fetch_running.fetch_sub(1, std::memory_order_relaxed);
-        }).detach();
-        return true;
-    }
-};
-
-} // namespace
-
-// REGRESSION - teardown must not return while a fetch it started is in flight.
-// The command worker parks a fetch before it reserves the in-flight slot, forcing
-// the "wait already observed zero" interleaving deterministically.
-TEST_CASE("an agent's destruction waits for a fetch started by its worker during teardown",
-          "[unit][moonraker][Regression]")
-{
-    g_deferred_fetch_running.store(0);
-    g_deferred_destroy_returned.store(false);
-
-    auto agent        = std::make_shared<DeferredFetchAgent>(std::string{});
-    auto entered      = agent->entered;
-    auto allow_fetch  = agent->allow_fetch;
-    auto allow_finish = agent->allow_finish;
-    auto running      = agent->running;
-
-    // Safety net for the pre-destroyer failure paths: release both gates before the
-    // agent is destroyed (declared after it, so destroyed before it).
-    ScopedPromiseRelease release_finish{allow_finish};
-    ScopedPromiseRelease release_fetch{allow_fetch};
-
-    // Park a fetch inside the command worker while the agent is still complete.
-    agent->post([ptr = agent.get()] { ptr->fetch_filament_info("dev", FilamentSyncMode::pull); });
-    REQUIRE(entered->get_future().wait_for(std::chrono::seconds(5)) == std::future_status::ready);
-
-    // Destroy on another thread so this one can drive the parked fetch.
-    std::thread destroyer([owned = std::move(agent)]() mutable {
-        owned.reset();
-        g_deferred_destroy_returned.store(true);
-    });
-    // Releases both gates before joining, so a failing REQUIRE cannot deadlock the join.
-    ScopedJoiner join_destroyer{destroyer, allow_fetch, allow_finish};
-
-    // Let the worker reserve the in-flight slot and spawn its fetch, then wait until it
-    // is genuinely parked (no polling).
-    allow_fetch->set_value();
-    REQUIRE(running->get_future().wait_for(std::chrono::seconds(5)) == std::future_status::ready);
-    REQUIRE(g_deferred_fetch_running.load() == 1);
-
-    // A correct teardown cannot return while the fetch is parked; give a buggy one time.
-    for (int i = 0; i < 200 && !g_deferred_destroy_returned.load(); ++i)
-        std::this_thread::sleep_for(std::chrono::milliseconds(10));
-
-    if (g_deferred_destroy_returned.load()) {
-        // Bug: teardown returned with a fetch still running. Don't release allow_finish.
-        CHECK(g_deferred_fetch_running.load() == 0);
-        return;
-    }
-
-    // Fixed order: destruction is still blocked on the in-flight fetch.
-    allow_finish->set_value();
-    destroyer.join();
-    CHECK(g_deferred_destroy_returned.load());
-    CHECK(g_deferred_fetch_running.load() == 0);
-}
-
 // ===========================================================================
 // UNIT - printer-agent registry duplicate handling.
 // Confirms a duplicate agent id is rejected so a plugin cannot shadow a built-in

tests/slic3rutils/test_qidi_printer_agent.cpp

@@ -1,134 +0,0 @@
-#include "catch2/catch_test_macros.hpp"
-#include "catch2/matchers/catch_matchers.hpp"
-#include "catch2/matchers/catch_matchers_string.hpp"
-#include <catch2/catch_all.hpp>
-
-#include <nlohmann/json.hpp>
-
-#include <slic3r/Utils/QidiPrinterAgent.hpp>
-
-#include <string>
-
-using namespace Slic3r;
-
-TEST_CASE("Qidi slot response rejects null variables without throwing", "[QidiPrinterAgent]")
-{
-    const std::string response = R"({
-        "result": {
-            "status": {
-                "save_variables": {
-                    "variables": null
-                }
-            }
-        }
-    })";
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = true;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
-    CHECK_FALSE(parsed);
-    CHECK_THAT(error, Catch::Matchers::ContainsSubstring("variables"));
-    CHECK_THAT(error, Catch::Matchers::ContainsSubstring("object"));
-}
-
-TEST_CASE("Qidi slot response rejects missing and non-object fields without throwing", "[QidiPrinterAgent]")
-{
-    std::string response;
-
-    SECTION("missing result")
-    {
-        response = R"({})";
-    }
-
-    SECTION("non-object result")
-    {
-        response = R"({"result":null})";
-    }
-
-    SECTION("missing status")
-    {
-        response = R"({"result":{}})";
-    }
-
-    SECTION("non-object status")
-    {
-        response = R"({"result":{"status":null}})";
-    }
-
-    SECTION("missing save_variables")
-    {
-        response = R"({"result":{"status":{}}})";
-    }
-
-    SECTION("non-object save_variables")
-    {
-        response = R"({"result":{"status":{"save_variables":null}}})";
-    }
-
-    SECTION("missing variables")
-    {
-        response = R"({"result":{"status":{"save_variables":{}}}})";
-    }
-
-    SECTION("scalar")
-    {
-        response = R"({"result":{"status":{"save_variables":{"variables":42}}}})";
-    }
-
-    SECTION("array")
-    {
-        response = R"({"result":{"status":{"save_variables":{"variables":[]}}}})";
-    }
-
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = true;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
-    CHECK_FALSE(parsed);
-}
-
-TEST_CASE("Qidi slot response exposes valid status and variables", "[QidiPrinterAgent]")
-{
-    const std::string response = R"({
-        "result": {
-            "status": {
-                "save_variables": {
-                    "variables": {
-                        "box_count": 2,
-                        "color_slot0": 3
-                    }
-                },
-                "box_stepper slot0": {
-                    "runout_button": 0
-                }
-            }
-        }
-    })";
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = false;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response(response, status, variables, error));
-    REQUIRE(parsed);
-    CHECK(status.is_object());
-    CHECK(variables.is_object());
-    CHECK(variables.at("box_count") == 2);
-    CHECK(status.contains("box_stepper slot0"));
-}
-
-TEST_CASE("Qidi slot response rejects invalid JSON", "[QidiPrinterAgent]")
-{
-    nlohmann::json status;
-    nlohmann::json variables;
-    std::string    error;
-    bool           parsed = true;
-
-    REQUIRE_NOTHROW(parsed = QidiPrinterAgent::parse_slot_response("{not json", status, variables, error));
-    CHECK_FALSE(parsed);
-    CHECK(error == "Invalid JSON response");
-}