fix: regression removed announc_printhost_device

(cherry picked from commit c6d3e755ec)

localization/i18n/OrcaSlicer.pot

@@ -10657,9 +10657,6 @@ msgstr ""
 msgid "Send Failed"
 msgstr ""
 
-msgid "No available printers"
-msgstr ""
-
 msgid "The name length exceeds the limit."
 msgstr ""
 

src/libslic3r/Preset.hpp

@@ -756,14 +756,7 @@ public:
     Preset&         get_edited_preset()         { return m_edited_preset; }
     const Preset&   get_edited_preset() const   { return m_edited_preset; }
 
-    // The root of the selected preset's inherits chain, or the selected preset itself when
+    const Preset& get_selected_preset_base() const { return *get_preset_base(m_presets[m_idx_selected]); }
-    // the chain names a preset that is not loaded (e.g. a vendor that is not installed).
-    const Preset& get_selected_preset_base() const
-    {
-        const Preset &selected = m_presets[m_idx_selected];
-        const Preset *base     = get_preset_base(selected);
-        return base ? *base : selected;
-    }
 
     // Return the last saved preset.
 //  const Preset&   get_saved_preset() const { return m_saved_preset; }

src/slic3r/GUI/ConnectPrinter.cpp

@@ -15,6 +15,7 @@
 #include <string>
 #include "slic3r/GUI/wxExtensions.hpp"
 #include "libslic3r/AppConfig.hpp"
+#include "IPrinterAgent.hpp"
 
 #include "DeviceCore/DevManager.h"
 
@@ -170,14 +171,16 @@ void ConnectPrinterDialog::on_input_enter(wxCommandEvent& evt)
 void ConnectPrinterDialog::on_button_confirm(wxCommandEvent &event)
 {
     wxString code = m_textCtrl_code->GetTextCtrl()->GetValue();
-    if (code.empty() && (!m_obj || m_obj->printer_agent_id != MOONRAKER_PRINTER_AGENT_ID))
+    // Validate only what the user typed; the no-key sentinel is applied afterwards (it contains
-        code = "88888888";
+    // non-alphanumeric characters, so it must not go through this check).
     for (char c : code) {
         if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'))) {
             show_error(this, _L("Invalid input"));
             return;
         }
     }
+    if (code.empty())
+        code = NO_API_KEY_SENTINEL;
     if (m_obj) {
         m_obj->set_access_code(code.ToStdString());
     }

src/slic3r/GUI/CreatePresetsDialog.cpp

@@ -3151,7 +3151,7 @@ void CreatePrinterPresetDialog::set_current_visible_printer()
     m_printer_name_to_preset.clear();
     for (const Preset &printer_preset : printer_presets) {
         if (!printer_preset.is_visible) continue;
-        if (preset_bundle->printers.get_preset_base(printer_preset) != &printer_preset) continue;
+        if (preset_bundle->printers.get_preset_base(printer_preset)->name != printer_preset.name) continue;
         if (auto printer_model = dynamic_cast<ConfigOptionString*>(const_cast<Preset&>(printer_preset).config.option("printer_model", false))) {
             if (m_printer_name_to_preset.find(printer_model->value) == m_printer_name_to_preset.end()) {
                 printer_choice.push_back(from_u8(printer_model->value));
@@ -4962,7 +4962,7 @@ void CreatePresetForPrinterDialog::get_visible_printer_and_compatible_filament_p
                     if (filament_preset.is_default || !filament_preset.is_compatible || filament_preset.is_project_embedded) continue;
                     ConfigOptionStrings *filament_types;
                     const Preset *       filament_preset_base = m_preset_bundle->filaments.get_preset_base(filament_preset);
-                    if (filament_preset_base == &filament_preset || filament_preset_base == nullptr) {
+                    if (filament_preset_base == &filament_preset) {
                         filament_types = dynamic_cast<ConfigOptionStrings *>(const_cast<Preset *>(&filament_preset)->config.option("filament_type"));
                     } else {
                         filament_types = dynamic_cast<ConfigOptionStrings *>(const_cast<Preset *>(filament_preset_base)->config.option("filament_type"));

src/slic3r/GUI/DeviceManager.cpp

@@ -2685,7 +2685,8 @@ int MachineObject::connect()
 {
     if (m_access_revoked || get_dev_ip().empty()) return -1;
     std::string username = m_agent ? m_agent->default_lan_username() : std::string();
-    std::string password = get_access_code();
+    // The stored access code may be the "no API key" sentinel; agents expect an empty credential.
+    std::string password = normalize_access_code(get_access_code());
 
     std::string port;
     std::string input = get_dev_ip();

src/slic3r/GUI/GUI_App.cpp

@@ -4354,6 +4354,11 @@ void GUI_App::select_machine(const std::string& agent_id)
         machine.dev_ip = dev_id;
         machine.dev_name = dev_id;
         machine.printer_type = preset.config.opt_string("printer_model");
+        auto access_code = preset.config.opt_string("printhost_apikey");
+        // Orca expect non empty access code
+        if (access_code.empty()) {
+            access_code = NO_API_KEY_SENTINEL;
+        }
 
         existing = m_device_manager->insert_local_device(
             machine, "lan", "free", "", access_code);

src/slic3r/GUI/ReleaseNote.cpp

@@ -2,6 +2,7 @@
 #include "I18N.hpp"
 
 #include "bambu_networking.hpp"
+#include "IPrinterAgent.hpp"
 #include "libslic3r/Utils.hpp"
 #include "GUI.hpp"
 #include "GUI_App.hpp"
@@ -1903,7 +1904,7 @@ void InputIpAddressDialog::on_ok(wxMouseEvent& evt)
     std::string str_ip = m_input_ip->GetTextCtrl()->GetValue().ToStdString();
     std::string str_access_code = m_input_access_code->GetTextCtrl()->GetValue().ToStdString();
     if (str_access_code.empty())
-        str_access_code = "88888888";
+        str_access_code = NO_API_KEY_SENTINEL;
     std::string str_name = m_input_printer_name->GetTextCtrl()->GetValue().Strip(wxString::both).ToStdString();
     // Serial number should not contain lower case letters, and bambu_network plugin crashes
     // if user entered the wrong serial number, so we call `Upper()` here.
@@ -1950,7 +1951,7 @@ void InputIpAddressDialog::on_send_retry()
     wxString ip              = m_input_ip->GetTextCtrl()->GetValue();
     wxString str_access_code = m_input_access_code->GetTextCtrl()->GetValue();
     if (str_access_code.IsEmpty())
-        str_access_code = "88888888";
+        str_access_code = NO_API_KEY_SENTINEL;
 
     // check support function
     if (!m_obj) return;

src/slic3r/GUI/SelectMachine.cpp

@@ -4087,7 +4087,7 @@ void SelectMachineDialog::update_user_printer()
     {
         m_printer_last_select = "";
         update_select_layout(nullptr);
-        m_printer_box->GetPrinterComboBox()->SetValue(_L("No available printers"));
+        m_printer_box->GetPrinterComboBox()->SetTextLabel("");
     }
 
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "for send task, current printer id =  " << m_printer_last_select << std::endl;

src/slic3r/GUI/SendToPrinter.cpp

@@ -1229,7 +1229,7 @@ void SendToPrinterDialog::update_user_printer()
     }
     else {
         m_printer_last_select = "";
-        m_comboBox_printer->SetValue(_L("No available printers"));
+        m_comboBox_printer->SetTextLabel("");
     }
 
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "for send task, current printer id =  " << m_printer_last_select << std::endl;

src/slic3r/GUI/Widgets/ComboBox.cpp

@@ -287,7 +287,7 @@ void ComboBox::DoDeleteOneItem(unsigned int pos)
 
 void ComboBox::ForceDropdownOpen()
 {
-    if (!IsEnabled() || items.empty())
+    if (!IsEnabled())
         return;
 
     if (!drop_down) {
@@ -398,7 +398,7 @@ void ComboBox::mouseDown(wxMouseEvent &event)
     SetFocus();
     if (drop_down) {
         drop.Hide();
-    } else if (!items.empty() && drop.HasDismissLongTime()) { // DropDown paints nothing for an empty list
+    } else if (drop.HasDismissLongTime()) {
         drop.autoPosition();
         drop_down = true;
         drop.Popup(&drop);
@@ -426,7 +426,7 @@ void ComboBox::keyDown(wxKeyEvent& event)
         case WXK_SPACE:
             if (drop_down) {
                 drop.DismissAndNotify();
-            } else if (!items.empty() && drop.HasDismissLongTime()) {
+            } else if (drop.HasDismissLongTime()) {
                 drop.autoPosition();
                 drop_down = true;
                 drop.Popup();

src/slic3r/Utils/BBLPrinterAgent.cpp

@@ -204,8 +204,9 @@ 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;
@@ -215,8 +216,9 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
     }
 
     double value = input_val;
-    if (!is_core_xy && (axis == "Y" || axis == "Z"))
+    if (!is_core_xy && (axis == "Y" || axis == "Z")) {
-        value = -input_val;
+        value = -1.0 * input_val;
+    }
 
     std::string value_str = (boost::format("%.1f") % (value * unit)).str();
     std::string gcode;
@@ -237,10 +239,11 @@ 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;
 }
 
@@ -586,8 +589,21 @@ 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)
 {
-    return dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
+    // 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>(
         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,6 +110,7 @@ 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/CrealityPrintAgent.cpp

@@ -288,22 +288,27 @@ 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 (device_info.dev_ip.empty()) {
+    if (sync_mode != get_filament_sync_mode())
+        return false;
+
+    const MoonrakerDeviceInfo info = snapshot_device_info();
+
+    if (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));
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
     }
 
     // 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://" + device_info.dev_ip));
+    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + 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(device_info.api_key));
+    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(info.api_key));
     cfg.set_key_value("printhost_ssl_ignore_revoke", new ConfigOptionBool(false));
 
     CrealityPrint host(&cfg);
@@ -313,7 +318,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         BOOST_LOG_TRIVIAL(info)
             << "CrealityPrintAgent: " << host.model_name()
             << " is not CFS-capable, deferring to base Moonraker agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
     }
 
     BOOST_LOG_TRIVIAL(info)
@@ -328,7 +333,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         BOOST_LOG_TRIVIAL(warning)
             << "CrealityPrintAgent: CFS query failed (" << parse_err << "), "
             << "falling back to base agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
     }
 
     if (box_count == 0) {
@@ -337,7 +342,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         // Moonraker exposes.
         BOOST_LOG_TRIVIAL(info)
             << "CrealityPrintAgent: no active CFS boxes, deferring to base agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
     }
 
     BOOST_LOG_TRIVIAL(info)
@@ -382,7 +387,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         }
     }
 
-    build_ams_payload(box_count, max_slots - 1, trays);
+    build_ams_payload(box_count, max_slots - 1, trays, sync_mode == FilamentSyncMode::pull);
     return true;
 }
 

src/slic3r/Utils/CrealityPrintAgent.hpp

@@ -37,12 +37,13 @@ public:
     };
 
     explicit CrealityPrintAgent(std::string log_dir);
-    ~CrealityPrintAgent() override = default;
+    ~CrealityPrintAgent() override { shutdown(); }
 
     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 { return FilamentSyncMode::pull; }
 
     // Parse the boxsInfo JSON returned by CrealityPrint::query_boxes_info() into
     // a flat list of loaded slots, plus the count of CFS boxes the printer reports.

src/slic3r/Utils/IPrinterAgent.hpp

@@ -45,6 +45,17 @@ struct PrinterConnectionParams
     std::string ca_file;
 };
 
+// Sentinel stored as a LAN device's access code when the user has not supplied one, so the device
+// stays registered (has_access_right() is !access_code.empty()). It is not a real credential: every
+// printer agent must translate it back to an empty string before using/sending it on the wire.
+inline constexpr const char* NO_API_KEY_SENTINEL = "*_{NO_API_KEY}_*";
+
+// Returns an empty string when `code` is the "no API key" sentinel, otherwise `code` unchanged.
+inline std::string normalize_access_code(const std::string& code)
+{
+    return code == NO_API_KEY_SENTINEL ? std::string() : code;
+}
+
 /**
  * FilamentSyncMode - Modes for filament data synchronization.
  *
@@ -455,9 +466,16 @@ public:
     virtual CameraStreamMode get_camera_stream_mode() const { return CameraStreamMode::none; }
 
     /**
-     * Refresh filament info from the printer synchronously.
+     * Refresh filament info from the printer.
-     * Should only be called when get_filament_sync_mode() returns FilamentSyncMode::pull.
+     *
-     * Populates the MachineObject's DevFilaSystem with fetched filament data.
+     * When called with FilamentSyncMode::pull (which requires get_filament_sync_mode() to
+     * return pull) this is a blocking, synchronous call: when it returns true the MachineObject's
+     * DevFilaSystem has already been populated and the caller may read it immediately.
+     *
+     * When called with FilamentSyncMode::subscription — by an implementation's own status loop —
+     * the refresh may be performed asynchronously: a true return then means the refresh was
+     * scheduled (or is already in flight), and DevFilaSystem is updated later on the main thread.
+     * Callers must not assume the data is ready on return.
      */
     virtual bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) { return false; }
 

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -13,6 +13,8 @@
 #include <set>
 #include <string>
 #include <thread>
+#include <condition_variable>
+#include <deque>
 
 #include <nlohmann/json.hpp>
 #include <vector>
@@ -21,6 +23,56 @@ 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:
@@ -66,12 +118,26 @@ 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;
     // 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;
+    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;
 
 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;
@@ -83,7 +149,9 @@ 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;
 
     // Copied when the stream starts, so changes apply to the next start_status_stream()
@@ -107,18 +175,47 @@ protected:
         int         nozzle_temp = 0;     // Optional
     };
 
-    // Build ams JSON and call parser
+    // Build ams JSON and call parser.
-    void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
+    // apply_inline: when true the MachineObject mutation runs on the calling thread, which
+    // must therefore be the main thread; when false it is deferred through queue_on_main_fn.
+    // Pull-mode fetches run synchronously on the GUI thread and are read back immediately, so
+    // they pass true to avoid the deferred mutation landing after the caller's read.
+    //
+    // resolve_tray_ids: optional hook that runs as part of the commit, i.e. on the main thread.
+    // Agents that would otherwise resolve tray_info_idx against GUI-owned preset state on a
+    // background fetch thread must do it here to avoid racing the GUI. It must not capture
+    // `this` (the commit may outlive the agent).
+    using ResolveAmsTrayIdsFn = std::function<void(std::vector<AmsTrayData>&)>;
+    void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays, bool apply_inline = false,
+                           ResolveAmsTrayIdsFn resolve_tray_ids = {});
 
     // Methods that derived classes may need to override or access
-    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 init_device_info(const PrinterConnectionParams& params);
-    virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
+    virtual bool fetch_device_info(const ConnectionSettings& connection, MoonrakerDeviceInfo& info, std::string& error) const;
-    void start_status_stream(const std::string& dev_id, const std::string& base_url, const std::string& api_key);
+    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);
+    // The connection is copied when the stream starts, so changes apply to the next start.
+    void start_status_stream(const std::string& dev_id, ConnectionSettings connection);
     void stop_status_stream();
 
     // 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);
@@ -131,13 +228,30 @@ 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 std::string& base_url, const std::string& api_key, std::set<std::string>& objects, std::string& error) const;
+    bool fetch_object_list(const ConnectionSettings& connection, 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 query_printer_status(const ConnectionSettings& connection, 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;
@@ -145,38 +259,46 @@ 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);
     // Joins a stream stopped from its own callback, so a new stream can start without waiting on it under connect_mutex
     void join_stopped_status_stream();
-    void run_status_stream(std::string dev_id, std::string base_url, std::string api_key, StatusStreamTimings timings);
+    void run_status_stream(std::string dev_id, ConnectionSettings connection, StatusStreamTimings timings);
-    void handle_ws_message(const std::string& dev_id, const std::string& payload);
+    void handle_ws_message(std::string dev_id, std::string payload, ConnectionSettings connection);
     void send_heartbeat_if_due(const std::string& dev_id, std::chrono::milliseconds interval);
+    void refresh_thumbnail_url(const ConnectionSettings& connection);
     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 std::string& base_url, const std::string& api_key,
+                      const ConnectionSettings& connection,
                       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,
-                                   const std::string& base_url,
+                                   ConnectionSettings connection,
-                                   const std::string& api_key,
                                    uint64_t generation);
 
+    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(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_hh_filament_info(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
-    bool fetch_moonraker_filament_data(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_moonraker_filament_data(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
 
     // JSON helper methods
     static std::string safe_json_string(const nlohmann::json& obj, const char* key);
@@ -202,16 +324,37 @@ 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;
-    std::mutex          ws_abort_mutex; // Guards ws_thread and ws_abort
+
-    std::function<void()> ws_abort; // Interrupts whatever the stream thread is waiting on, from any thread
+    // Guards ws_thread and ws_abort. ws_abort posts to the stream's io_context, cancelling the
+    // reconnect wait and interrupting whatever connection attempt is running, so stop is prompt
+    // even when the stream thread is blocked on connect, TLS, or a read.
+    std::mutex            ws_abort_mutex;
+    std::function<void()> ws_abort;  // guarded by ws_abort_mutex
+
+    // 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
@@ -222,7 +365,13 @@ private:
     // Connection thread management
     std::atomic<uint64_t>  connect_generation{0};
     std::thread            connect_thread;
-    std::recursive_mutex   connect_mutex;
+
+    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;
 };
 
 } // namespace Slic3r

src/slic3r/Utils/QidiPrinterAgent.cpp

@@ -2,18 +2,25 @@
 #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 <cmath>
 #include "libslic3r/Preset.hpp"
+#include <cstddef>
+#include <exception>
 #include <map>
+#include <mutex>
 #include <sstream>
+#include <thread>
 #include <string>
 #include <utility>
 #include <vector>
@@ -34,6 +41,40 @@ 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);
+    if (it == obj.end()) {
+        return fallback;
+    }
+    if (it->is_number_integer()) {
+        return it->get<int>();
+    }
+    // Firmware may report an integral field as a JSON float (e.g. 2.0). Accept it only when it
+    // has no fractional part, so a genuinely fractional value falls back instead of truncating.
+    if (it->is_number_float()) {
+        const double value = it->get<double>();
+        if (value == std::floor(value)) {
+            return static_cast<int>(value);
+        }
+    }
+    return fallback;
+}
+
 } // anonymous namespace
 
 const std::string QidiPrinterAgent_VERSION = "0.0.1";
@@ -47,51 +88,179 @@ AgentInfo QidiPrinterAgent::get_agent_info_static()
     return AgentInfo{"qidi", "Qidi", QidiPrinterAgent_VERSION, "Qidi printer agent"};
 }
 
-bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
+FilamentSyncMode QidiPrinterAgent::get_filament_sync_mode() const
 {
-    std::string error;
+    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
+        return FilamentSyncMode::subscription;
+    return FilamentSyncMode::pull;
+}
 
-    // 1. Fetch device info and infer series_id
+bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
-    std::string series_id;
+{
-    {
+    if (sync_mode != get_filament_sync_mode())
-        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);
-        }
-    }
-    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;
+
+    // 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;
+    {
+        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
+        model_id   = device_info.model_id;
+        model_name = device_info.model_name;
     }
 
-    // 4. Build the AMS payload
+    // One implementation for both modes; only where it runs differs. pull is the documented
-    build_ams_payload(box_count, box_count * 4 - 1, trays);
+    // blocking contract (the GUI thread reads DevFilaSystem right after the call), so it runs
+    // on the caller with the payload applied inline. subscription runs on a background thread
+    // so the status loop is not stalled, and the payload is marshalled back to the main thread.
+    auto work = [this, connection = std::move(connection), model_id, model_name](bool apply_inline) -> bool {
+        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 false;
+            }
+
+            // 4. Build the AMS payload, resolving preset-dependent ids on the main thread.
+            auto resolve_ids = [](std::vector<AmsTrayData>& resolved_trays) {
+                auto* bundle = GUI::wxGetApp().preset_bundle;
+                if (!bundle) {
+                    return; // keep the Qidi-specific ids computed from device data
+                }
+                for (auto& tray : resolved_trays) {
+                    if (!tray.has_filament) {
+                        continue;
+                    }
+                    if (!tray.tray_info_idx.empty() && has_visible_base_preset(bundle->filaments, tray.tray_info_idx)) {
+                        continue;
+                    }
+                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
+                }
+            };
+            build_ams_payload(box_count, box_count * 4 - 1, trays, apply_inline, resolve_ids);
+            return true;
+        } 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();
+            return false;
+        } catch (...) {
+            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::fetch_filament_info: unhandled exception";
+            return false;
+        }
+    };
+
+    if (sync_mode == FilamentSyncMode::pull) {
+        return work(/*apply_inline=*/true);
+    }
+
+    // Subscription: fire-and-forget. A `true` return means the refresh was scheduled (or is
+    // already running), not that DevFilaSystem has been updated. 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([work = std::move(work), guard = std::move(guard)]() mutable {
+        work(/*apply_inline=*/false);
+    }).detach();
     return true;
 }
 
-bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
+bool QidiPrinterAgent::apply_box_mapping(const PrintParams& params) const
-                                       const std::string&        api_key,
+{
+    // 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)
+{
+    // Only the LAN print path is implemented by the Moonraker base; the box config is emitted
+    // here, before the print starts. The cloud/record/sdcard variants inherited from the base
+    // deliberately return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED without side effects.
+    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);
+}
+
+bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
                                        const QidiFilamentDict&   dict,
                                        const std::string&        series_id,
                                        std::vector<AmsTrayData>& trays,
                                        int&                      box_count,
                                        std::string&              error)
 {
-    std::string url = join_url(base_url, "/printer/objects/query?save_variables=variables");
+    std::string url = join_url(connection.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";
     }
@@ -101,8 +270,9 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
     std::string http_error;
 
     auto http = Http::get(url);
-    if (!api_key.empty()) {
+    configure_http(http, connection);
-        http.header("X-Api-Key", api_key);
+    if (!connection.api_key.empty()) {
+        http.header("X-Api-Key", connection.api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)
@@ -127,22 +297,12 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
         return false;
     }
 
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    nlohmann::json status;
-    if (json.is_discarded()) {
+    nlohmann::json variables;
-        error = "Invalid JSON response";
+    if (!parse_slot_response(response_body, status, variables, error))
         return false;
-    }
 
-    if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("save_variables") ||
+    box_count = read_int_or(variables, "box_count", 1);
-        !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;
     }
@@ -165,9 +325,9 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
         tray.slot_index = i;
 
         // Read slot variables
-        const int color_index     = variables.value("color_slot" + std::to_string(i), 1);
+        const int color_index     = read_int_or(variables, "color_slot" + std::to_string(i), 1);
-        const int filament_type   = variables.value("filament_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     = variables.value("vendor_slot" + std::to_string(i), 0);
+        const int vendor_type     = read_int_or(variables, "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);
@@ -175,7 +335,7 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
         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()) {
-                int runout_button = box_stepper["runout_button"].template get<int>();
+                const int runout_button = read_int_or(box_stepper, "runout_button", 0);
                 tray.has_filament = (runout_button == 0);
             }
         }
@@ -189,16 +349,9 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
             }
             tray.tray_type = normalize_filament_type(filament_name);
 
-            // Try Qidi-specific setting ID first; fall back to visible preset by type
+            // Qidi-specific setting id derived from device data only; the preset-dependent
-            std::string setting_id = build_setting_id(filament_type, vendor_type, tray.tray_type);
+            // fallback runs on the main thread in the resolve hook passed to build_ams_payload.
-            auto* bundle = GUI::wxGetApp().preset_bundle;
+            tray.tray_info_idx = build_setting_id(filament_type, vendor_type, tray.tray_type);
-            if (!bundle) {
-                tray.tray_info_idx = setting_id;
-            } else if (!setting_id.empty() && has_visible_base_preset(bundle->filaments, setting_id)) {
-                tray.tray_info_idx = setting_id;
-            } else {
-                tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
-            }
 
             // Look up color from dictionary
             auto color_it = dict.colors.find(color_index);
@@ -215,20 +368,45 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
     return true;
 }
 
-bool QidiPrinterAgent::fetch_filament_dict(const std::string& base_url,
+bool QidiPrinterAgent::parse_slot_response(const std::string& response_body,
-                                           const std::string& api_key,
+                                           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,
                                            QidiFilamentDict& dict,
                                            std::string& error) const
 {
-    std::string url = join_url(base_url, "/server/files/config/officiall_filas_list.cfg");
+    std::string url = join_url(connection.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);
-    if (!api_key.empty()) {
+    configure_http(http, connection);
-        http.header("X-Api-Key", api_key);
+    if (!connection.api_key.empty()) {
+        http.header("X-Api-Key", connection.api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)

src/slic3r/Utils/QidiPrinterAgent.hpp

@@ -3,6 +3,8 @@
 
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
+#include "bambu_networking.hpp"
+#include "nlohmann/json_fwd.hpp"
 
 #include <map>
 #include <string>
@@ -14,7 +16,7 @@ class QidiPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit QidiPrinterAgent(std::string log_dir);
-    ~QidiPrinterAgent() override = default;
+    ~QidiPrinterAgent() override { shutdown(); }
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
@@ -22,7 +24,22 @@ 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.
+    // Only the LAN print path is supported by the base; the cloud/record/sdcard variants
+    // are inherited and return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.
+    int start_local_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;
@@ -30,14 +47,13 @@ private:
     };
 
     // Qidi-specific methods
-    bool fetch_slot_info(const std::string&        base_url,
+    bool fetch_slot_info(const ConnectionSettings& connection,
-                         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 std::string& base_url, const std::string& api_key, QidiFilamentDict& dict, std::string& error) const;
+    bool fetch_filament_dict(const ConnectionSettings& connection, 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,11 +2,20 @@
 #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 <cmath>
+#include <cstdint>
+#include <exception>
+#include <mutex>
+#include <sstream>
+#include <thread>
 #include <vector>
 #include <string>
 #include "libslic3r/Preset.hpp"
@@ -18,6 +27,91 @@ 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);
+    if (it == obj.end()) {
+        return fallback;
+    }
+    if (it->is_number_integer()) {
+        return it->get<int>();
+    }
+    // Firmware may report an integral field as a JSON float (e.g. 2.0). Accept it only when it
+    // has no fractional part, so a genuinely fractional value falls back instead of truncating.
+    if (it->is_number_float()) {
+        const double value = it->get<double>();
+        if (value == std::floor(value)) {
+            return static_cast<int>(value);
+        }
+    }
+    return 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>
@@ -40,14 +134,16 @@ 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
+            // so we must remove # and ignore alpha channel for distance calculation. Firmware
-            unsigned int target_color_value = std::stoul(color_rgba.substr(0, color_rgba.length() - 2), nullptr, 16);
+            // 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));
 
             std::string  p_color = p.config.opt_string("default_filament_colour", 0u);
-            unsigned int p_color_value;
+            unsigned int p_color_value = 0;
             if (!p_color.empty()) {
-                size_t       hash_pos = p_color.find("#");
+                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);
+                p_color_value   = parse_hex_color(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0));
             } 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
@@ -74,6 +170,31 @@ 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"};
@@ -109,127 +230,192 @@ 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)
 {
-    std::string url = join_url(device_info.base_url, "/printer/objects/query?print_task_config&filament_detect");
+    (void) dev_id;
+    if (sync_mode != get_filament_sync_mode())
+        return false;
 
-    std::string response_body;
+    // Snapshot everything the fetch needs (URL, api key, TLS/CA): a reconnect can rewrite
-    bool        success = false;
+    // device_info meanwhile.
-    std::string http_error;
+    const ConnectionSettings connection = get_connection_settings();
 
-    auto http = Http::get(url);
+    // One implementation for both modes; only where it runs differs. pull is the documented
-    if (!device_info.api_key.empty()) {
+    // blocking contract (the GUI thread reads DevFilaSystem right after the call), so it runs
-        http.header("X-Api-Key", device_info.api_key);
+    // on the caller with the payload applied inline. subscription runs on a background thread
-    }
+    // so the status loop is not stalled, and the payload is marshalled back to the main thread.
-    http.timeout_connect(5)
+    auto work = [this, connection](bool apply_inline) -> bool {
-        .timeout_max(10)
+        try {
-        .on_complete([&](std::string body, unsigned status) {
+            const std::string url = join_url(connection.base_url, "/printer/objects/query?print_task_config&filament_detect");
-            if (status == 200) {
+
-                response_body = body;
+            std::string response_body;
-                success       = true;
+            bool success = false;
-            } else {
+            std::string http_error;
-                http_error = "HTTP error: " + std::to_string(status);
+
+            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)
-        .on_error([&](std::string body, std::string err, unsigned status) {
+                .timeout_max(10)
-            http_error = err;
+                .on_complete([&](std::string body, unsigned status) {
-            if (status > 0) {
+                    if (status == 200) {
-                http_error += " (HTTP " + std::to_string(status) + ")";
+                        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;
             }
-        })
-        .perform_sync();
 
-    if (!success) {
+            auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
+            if (json.is_discarded()) {
-        return false;
+                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
-    }
+                return false;
+            }
 
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+            // Navigate to result.status.print_task_config
-    if (json.is_discarded()) {
+            if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("print_task_config")) {
-        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
+                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
-        return false;
+                return false;
-    }
+            }
 
-    // Navigate to result.status.print_task_config
+            auto& ptc = json["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& ptc = json["result"]["status"]["print_task_config"];
+            // 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");
 
-    // Read parallel arrays from print_task_config
+            const int slot_count = static_cast<int>(filament_exist.size());
-    auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
+            if (slot_count == 0) {
-    auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
+                BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
-    auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
+                return false;
-    auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
+            }
-    auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
 
-    const int slot_count = static_cast<int>(filament_exist.size());
+            // Read NFC filament_detect data for temperature info (optional)
-    if (slot_count == 0) {
+            nlohmann::json nfc_info;
-        BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
+            if (json["result"]["status"].contains("filament_detect") && json["result"]["status"]["filament_detect"].contains("info")) {
-        return false;
+                nfc_info = json["result"]["status"]["filament_detect"]["info"];
-    }
+            }
 
-    // Read NFC filament_detect data for temperature info (optional)
+            static const std::string empty_str;
-    nlohmann::json nfc_info;
+            static const std::string default_color = "FFFFFFFF";
-    if (json["result"]["status"].contains("filament_detect") &&
-        json["result"]["status"]["filament_detect"].contains("info")) {
-        nfc_info = json["result"]["status"]["filament_detect"]["info"];
-    }
 
-    static const std::string empty_str;
+            // Per-tray vendor names, kept so the preset lookup can run on the main thread.
-    static const std::string default_color = "FFFFFFFF";
+            std::vector<std::string> vendors(slot_count);
 
-    std::vector<AmsTrayData> trays;
+            std::vector<AmsTrayData> trays;
-    trays.reserve(slot_count);
+            trays.reserve(slot_count);
 
-    for (int i = 0; i < slot_count; ++i) {
+            for (int i = 0; i < slot_count; ++i) {
-        AmsTrayData tray;
+                AmsTrayData tray;
-        tray.slot_index   = i;
+                tray.slot_index   = i;
-        tray.has_filament = filament_exist[i];
+                tray.has_filament = filament_exist[i];
 
-        if (tray.has_filament) {
+                if (tray.has_filament) {
-            tray.tray_type     = combine_filament_type(safe_at(filament_type, i, empty_str),
+                    tray.tray_type  = combine_filament_type(safe_at(filament_type, i, empty_str), safe_at(filament_sub_type, i, empty_str));
-                                                       safe_at(filament_sub_type, i, empty_str));
+                    tray.tray_color = safe_at(filament_color, i, default_color);
-            tray.tray_color    = safe_at(filament_color, i, default_color);
+                    vendors[i]      = safe_at(filament_vendor, i, empty_str);
 
-            auto* bundle = GUI::wxGetApp().preset_bundle;
+                    // Generic id derived from device data only; the preset-dependent lookup runs
-            // Try to find a matching preset for this filament based on vendor, type and color.
+                    // on the main thread in the resolve hook passed to build_ams_payload.
-            // If not found, default to traditional search by type only or generic type mapping.
+                    tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
-            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()) {
+                    // Extract NFC temperature data if available
-                    tray.tray_info_idx = filament_id;
+                    if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
-                    BOOST_LOG_TRIVIAL(warning) << "Filament sync: Found manufacturer-specific profile for slot " << i << ": "
+                        auto&       nfc_slot = nfc_info[i];
-                                               << filament_id;
+                        std::string vendor   = "NONE";
-                } else {
+                        if (auto vendor_it = nfc_slot.find("VENDOR"); vendor_it != nfc_slot.end() && vendor_it->is_string()) {
-                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
+                            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);
+                        }
+                    }
                 }
-            } else {
+
-                tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
+                trays.emplace_back(std::move(tray));
             }
 
-            // Extract NFC temperature data if available
+            // Resolve against GUI-owned presets on the main thread (inside build_ams_payload).
-            if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
+            auto resolve_ids = [vendors](std::vector<AmsTrayData>& resolved_trays) {
-                auto& nfc_slot = nfc_info[i];
+                auto* bundle = GUI::wxGetApp().preset_bundle;
-                std::string vendor = nfc_slot.value("VENDOR", "NONE");
+                if (!bundle) {
-                if (vendor != "NONE" && !vendor.empty()) {
+                    return; // keep the generic ids computed from device data
-                    tray.bed_temp    = nfc_slot.value("BED_TEMP", 0);
-                    tray.nozzle_temp = nfc_slot.value("FIRST_LAYER_TEMP", 0);
                 }
-            }
+                for (size_t i = 0; i < resolved_trays.size() && i < vendors.size(); ++i) {
+                    AmsTrayData& tray = resolved_trays[i];
+                    if (!tray.has_filament) {
+                        continue;
+                    }
+                    // Prefer a manufacturer/colour-specific preset, else fall back to type.
+                    std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendors[i], tray.tray_type,
+                                                                                           tray.tray_color);
+                    tray.tray_info_idx = filament_id.empty() ? bundle->filaments.filament_id_by_type(tray.tray_type) : filament_id;
+                }
+            };
+            build_ams_payload(1, slot_count - 1, trays, apply_inline, resolve_ids);
+            return true;
+        } 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();
+            return false;
+        } catch (...) {
+            BOOST_LOG_TRIVIAL(error) << "SnapmakerPrinterAgent::fetch_filament_info: unhandled exception";
+            return false;
         }
+    };
 
-        trays.emplace_back(std::move(tray));
+    if (sync_mode == FilamentSyncMode::pull) {
+        return work(/*apply_inline=*/true);
     }
 
-    build_ams_payload(1, slot_count - 1, trays);
+    // Subscription: fire-and-forget. A `true` return means the refresh was scheduled (or is
+    // already running), not that DevFilaSystem has been updated. 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([work = std::move(work), guard = std::move(guard)]() mutable {
+        work(/*apply_inline=*/false);
+    }).detach();
     return true;
 }
 
+std::string SnapmakerPrinterAgent::get_camera_url() const
+{
+    return join_url(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,6 +3,8 @@
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 
+#include <atomic>
+#include <cstdint>
 #include <string>
 
 namespace Slic3r {
@@ -11,16 +13,25 @@ class SnapmakerPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit SnapmakerPrinterAgent(std::string log_dir);
-    ~SnapmakerPrinterAgent() override = default;
+    ~SnapmakerPrinterAgent() override { shutdown(); }
 
     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

src/slic3r/plugin/PythonInterpreter.cpp

@@ -584,19 +584,6 @@ bool PythonInterpreter::initialize()
         }
         BOOST_LOG_TRIVIAL(debug) << "Program name set successfully";
 
-        // Keep bytecode out of the Python home. The shipped .pyc files are stale against their
-        // sources, so a writable install would rewrite them inside the app (breaking a signed
-        // macOS bundle's seal) and a read-only one would recompile them on every launch.
-        const std::string pycache_prefix = data_dir() + "/python/pycache";
-#ifdef _WIN32
-        status = PyConfig_SetString(&config, &config.pycache_prefix, boost::nowide::widen(pycache_prefix).c_str());
-#else
-        status = PyConfig_SetBytesString(&config, &config.pycache_prefix, pycache_prefix.c_str());
-#endif
-        if (PyStatus_Exception(status))
-            BOOST_LOG_TRIVIAL(warning) << "Failed to set the Python bytecode cache to " << pycache_prefix << ": "
-                                       << (status.err_msg ? status.err_msg : "unknown error");
-
         // Use pybind11's scoped_interpreter which properly initializes
         // pybind11 internals for multi-threaded use — raw Py_InitializeFromConfig
         // does not set up thread state tracking that pybind11 requires.

tests/data/test_stl/ASCII/20mmbox-CR.stl

@@ -0,0 +1 @@
+solid STL generated by MeshLab
  facet normal  0.000000e+00 -0.000000e+00 -1.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  0.000000e+00
      vertex   2.000000e+01  0.000000e+00  0.000000e+00
      vertex   0.000000e+00  0.000000e+00  0.000000e+00
    endloop
  endfacet
  facet normal -0.000000e+00  0.000000e+00 -1.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  0.000000e+00
      vertex   0.000000e+00  0.000000e+00  0.000000e+00
      vertex   0.000000e+00  2.000000e+01  0.000000e+00
    endloop
  endfacet
  facet normal  0.000000e+00  0.000000e+00  1.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  2.000000e+01
      vertex   0.000000e+00  2.000000e+01  2.000000e+01
      vertex   0.000000e+00  0.000000e+00  2.000000e+01
    endloop
  endfacet
  facet normal  0.000000e+00  0.000000e+00  1.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  2.000000e+01
      vertex   0.000000e+00  0.000000e+00  2.000000e+01
      vertex   2.000000e+01  0.000000e+00  2.000000e+01
    endloop
  endfacet
  facet normal  1.000000e+00  0.000000e+00 -0.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  0.000000e+00
      vertex   2.000000e+01  2.000000e+01  2.000000e+01
      vertex   2.000000e+01  0.000000e+00  2.000000e+01
    endloop
  endfacet
  facet normal  1.000000e+00  0.000000e+00  0.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  0.000000e+00
      vertex   2.000000e+01  0.000000e+00  2.000000e+01
      vertex   2.000000e+01  0.000000e+00  0.000000e+00
    endloop
  endfacet
  facet normal  0.000000e+00 -1.000000e+00  0.000000e+00
    outer loop
      vertex   2.000000e+01  0.000000e+00  0.000000e+00
      vertex   2.000000e+01  0.000000e+00  2.000000e+01
      vertex   0.000000e+00  0.000000e+00  2.000000e+01
    endloop
  endfacet
  facet normal  0.000000e+00 -1.000000e+00  0.000000e+00
    outer loop
      vertex   2.000000e+01  0.000000e+00  0.000000e+00
      vertex   0.000000e+00  0.000000e+00  2.000000e+01
      vertex   0.000000e+00  0.000000e+00  0.000000e+00
    endloop
  endfacet
  facet normal -1.000000e+00  0.000000e+00  0.000000e+00
    outer loop
      vertex   0.000000e+00  0.000000e+00  0.000000e+00
      vertex   0.000000e+00  0.000000e+00  2.000000e+01
      vertex   0.000000e+00  2.000000e+01  2.000000e+01
    endloop
  endfacet
  facet normal -1.000000e+00  0.000000e+00  0.000000e+00
    outer loop
      vertex   0.000000e+00  0.000000e+00  0.000000e+00
      vertex   0.000000e+00  2.000000e+01  2.000000e+01
      vertex   0.000000e+00  2.000000e+01  0.000000e+00
    endloop
  endfacet
  facet normal  0.000000e+00  1.000000e+00  0.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  2.000000e+01
      vertex   2.000000e+01  2.000000e+01  0.000000e+00
      vertex   0.000000e+00  2.000000e+01  0.000000e+00
    endloop
  endfacet
  facet normal  0.000000e+00  1.000000e+00  0.000000e+00
    outer loop
      vertex   2.000000e+01  2.000000e+01  2.000000e+01
      vertex   0.000000e+00  2.000000e+01  0.000000e+00
      vertex   0.000000e+00  2.000000e+01  2.000000e+01
    endloop
  endfacet
endsolid vcg

tests/fff_print/test_fill.cpp

@@ -44,6 +44,7 @@
 #include "libslic3r/Layer.hpp"
 #include "libslic3r/Print.hpp"
 #include "libslic3r/PrintConfig.hpp"
+#include "libslic3r/SVG.hpp"
 #include "libslic3r/libslic3r.h"
 
 #include "test_helpers.hpp"
@@ -52,6 +53,15 @@ using namespace Slic3r;
 
 bool test_if_solid_surface_filled(const ExPolygon& expolygon, double flow_spacing, double angle = 0, double density = 1.0);
 
+#if 0
+TEST_CASE("Adjusted solid distance", "[Fill]") {
+    int surface_width = 250;
+    int distance = Slic3r::Flow::solid_spacing(surface_width, 47);
+    REQUIRE(distance == Catch::Approx(50));
+    REQUIRE(surface_width % distance == 0);
+}
+#endif
+
 TEST_CASE("Pattern path length", "[Fill]") {
     std::unique_ptr<Slic3r::Fill> filler(Slic3r::Fill::new_from_type("rectilinear"));
     filler->angle = float(-(PI)/2.0);
@@ -110,6 +120,15 @@ TEST_CASE("Pattern path length", "[Fill]") {
                 filler->angle = float(angle);
                 ExPolygon e(test_square, test_hole);
                 Slic3r::Polylines paths = test(e);
+#if 0
+				{
+					BoundingBox bbox = get_extents(e);
+					SVG svg("c:\\data\\temp\\square_with_holes.svg", bbox);
+					svg.draw(e);
+					svg.draw(paths);
+					svg.Close();
+				}
+#endif
                 REQUIRE((paths.size() >= 1 && paths.size() <= 3));
                 // paths don't cross hole
                 REQUIRE(diff_pl(paths, offset(e, float(SCALED_EPSILON*10))).size() == 0);
@@ -156,6 +175,25 @@ TEST_CASE("Pattern path length", "[Fill]") {
         }
     }
 
+    #if 0   // Disabled temporarily due to precision issues on the Mac VM
+    SECTION("Solid surface fill") {
+        Slic3r::Points points {
+            Point::new_scale(6883102, 9598327.01296997),
+            Point::new_scale(6883102, 20327272.01297),
+            Point::new_scale(3116896, 20327272.01297),
+            Point::new_scale(3116896, 9598327.01296997) 
+        };
+        Slic3r::ExPolygon expolygon(points);
+         
+        REQUIRE(test_if_solid_surface_filled(expolygon, 0.55) == true);
+        for (size_t i = 0; i <= 20; ++i)
+        {
+            expolygon.scale(1.05);
+            REQUIRE(test_if_solid_surface_filled(expolygon, 0.55) == true);
+        }
+    }
+    #endif
+
     SECTION("Solid surface fill") {
         Slic3r::Points points {
                 Slic3r::Point(59515297,5422499),Slic3r::Point(59531249,5578697),Slic3r::Point(59695801,6123186),
@@ -188,6 +226,245 @@ TEST_CASE("Pattern path length", "[Fill]") {
     }
 }
 
+/*
+{
+    my $collection = Slic3r::Polyline::Collection->new(
+            Slic3r::Polyline->new([0,15], [0,18], [0,20]),
+            Slic3r::Polyline->new([0,10], [0,8], [0,5]),
+            );
+    is_deeply
+        [ map $_->[Y], map @$_, @{$collection->chained_path_from(Slic3r::Point->new(0,30), 0)} ],
+        [20, 18, 15, 10, 8, 5],
+        'chained path';
+}
+
+{
+    my $collection = Slic3r::Polyline::Collection->new(
+            Slic3r::Polyline->new([4,0], [10,0], [15,0]),
+            Slic3r::Polyline->new([10,5], [15,5], [20,5]),
+            );
+    is_deeply
+        [ map $_->[X], map @$_, @{$collection->chained_path_from(Slic3r::Point->new(30,0), 0)} ],
+        [reverse 4, 10, 15, 10, 15, 20],
+        'chained path';
+}
+
+{
+    my $collection = Slic3r::ExtrusionPath::Collection->new(
+            map Slic3r::ExtrusionPath->new(polyline => $_, role => 0, mm3_per_mm => 1),
+            Slic3r::Polyline->new([0,15], [0,18], [0,20]),
+            Slic3r::Polyline->new([0,10], [0,8], [0,5]),
+            );
+    is_deeply
+        [ map $_->[Y], map @{$_->polyline}, @{$collection->chained_path_from(Slic3r::Point->new(0,30), 0)} ],
+        [20, 18, 15, 10, 8, 5],
+        'chained path';
+}
+
+{
+    my $collection = Slic3r::ExtrusionPath::Collection->new(
+            map Slic3r::ExtrusionPath->new(polyline => $_, role => 0, mm3_per_mm => 1),
+            Slic3r::Polyline->new([15,0], [10,0], [4,0]),
+            Slic3r::Polyline->new([10,5], [15,5], [20,5]),
+            );
+    is_deeply
+        [ map $_->[X], map @{$_->polyline}, @{$collection->chained_path_from(Slic3r::Point->new(30,0), 0)} ],
+        [reverse 4, 10, 15, 10, 15, 20],
+        'chained path';
+}
+
+for my $pattern (qw(rectilinear honeycomb hilbertcurve concentric)) {
+    my $config = Slic3r::Config->new_from_defaults;
+    $config->set('fill_pattern', $pattern);
+    $config->set('external_fill_pattern', $pattern);
+    $config->set('perimeters', 1);
+    $config->set('skirts', 0);
+    $config->set('fill_density', 20);
+    $config->set('layer_height', 0.05);
+    $config->set('perimeter_extruder', 1);
+    $config->set('infill_extruder', 2);
+    my $print = Slic3r::Test::init_print('20mm_cube', config => $config, scale => 2);
+    ok my $gcode = Slic3r::Test::gcode($print), "successful $pattern infill generation";
+    my $tool = undef;
+    my @perimeter_points = my @infill_points = ();
+    Slic3r::GCode::Reader->new->parse($gcode, sub {
+            my ($self, $cmd, $args, $info) = @_;
+
+            if ($cmd =~ /^T(\d+)/) {
+            $tool = $1;
+            } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
+            if ($tool == $config->perimeter_extruder-1) {
+            push @perimeter_points, Slic3r::Point->new_scale($args->{X}, $args->{Y});
+            } elsif ($tool == $config->infill_extruder-1) {
+            push @infill_points, Slic3r::Point->new_scale($args->{X}, $args->{Y});
+            }
+            }
+            });
+    my $convex_hull = convex_hull(\@perimeter_points);
+    ok !(defined first { !$convex_hull->contains_point($_) } @infill_points), "infill does not exceed perimeters ($pattern)";
+}
+
+{
+    my $config = Slic3r::Config->new_from_defaults;
+    $config->set('infill_only_where_needed', 1);
+    $config->set('bottom_solid_layers', 0);
+    $config->set('infill_extruder', 2);
+    $config->set('infill_extrusion_width', 0.5);
+    $config->set('fill_density', 40);
+    $config->set('cooling', 0);                 # for preventing speeds from being altered
+        $config->set('first_layer_speed', '100%');  # for preventing speeds from being altered
+
+        my $test = sub {
+            my $print = Slic3r::Test::init_print('pyramid', config => $config);
+
+            my $tool = undef;
+            my @infill_extrusions = ();  # array of polylines
+                Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
+                        my ($self, $cmd, $args, $info) = @_;
+
+                        if ($cmd =~ /^T(\d+)/) {
+                        $tool = $1;
+                        } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
+                        if ($tool == $config->infill_extruder-1) {
+                        push @infill_extrusions, Slic3r::Line->new_scale(
+                                [ $self->X, $self->Y ],
+                                [ $info->{new_X}, $info->{new_Y} ],
+                                );
+                        }
+                        }
+                        });
+            return 0 if !@infill_extrusions;  # prevent calling convex_hull() with no points
+
+                my $convex_hull = convex_hull([ map $_->pp, map @$_, @infill_extrusions ]);
+            return unscale unscale sum(map $_->area, @{offset([$convex_hull], scale(+$config->infill_extrusion_width/2))});
+        };
+
+    my $tolerance = 5;  # mm^2
+
+        $config->set('solid_infill_below_area', 0);
+    ok $test->() < $tolerance,
+       'no infill is generated when using infill_only_where_needed on a pyramid';
+
+    $config->set('solid_infill_below_area', 70);
+    ok abs($test->() - $config->solid_infill_below_area) < $tolerance,
+       'infill is only generated under the forced solid shells';
+}
+
+{
+    my $config = Slic3r::Config->new_from_defaults;
+    $config->set('skirts', 0);
+    $config->set('perimeters', 1);
+    $config->set('fill_density', 0);
+    $config->set('top_solid_layers', 0);
+    $config->set('bottom_solid_layers', 0);
+    $config->set('solid_infill_below_area', 20000000);
+    $config->set('solid_infill_every_layers', 2);
+    $config->set('perimeter_speed', 99);
+    $config->set('external_perimeter_speed', 99);
+    $config->set('cooling', 0);
+    $config->set('first_layer_speed', '100%');
+
+    my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
+    my %layers_with_extrusion = ();
+    Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
+            my ($self, $cmd, $args, $info) = @_;
+
+            if ($cmd eq 'G1' && $info->{dist_XY} > 0 && $info->{extruding}) {
+            if (($args->{F} // $self->F) != $config->perimeter_speed*60) {
+            $layers_with_extrusion{$self->Z} = ($args->{F} // $self->F);
+            }
+            }
+            });
+
+    ok !%layers_with_extrusion,
+       "solid_infill_below_area and solid_infill_every_layers are ignored when fill_density is 0";
+}
+
+{
+    my $config = Slic3r::Config->new_from_defaults;
+    $config->set('skirts', 0);
+    $config->set('perimeters', 3);
+    $config->set('fill_density', 0);
+    $config->set('layer_height', 0.2);
+    $config->set('first_layer_height', 0.2);
+    $config->set('nozzle_diameter', [0.35]);
+    $config->set('infill_extruder', 2);
+    $config->set('solid_infill_extruder', 2);
+    $config->set('infill_extrusion_width', 0.52);
+    $config->set('solid_infill_extrusion_width', 0.52);
+    $config->set('first_layer_extrusion_width', 0);
+
+    my $print = Slic3r::Test::init_print('A', config => $config);
+    my %infill = ();  # Z => [ Line, Line ... ]
+        my $tool = undef;
+    Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
+            my ($self, $cmd, $args, $info) = @_;
+
+            if ($cmd =~ /^T(\d+)/) {
+            $tool = $1;
+            } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
+            if ($tool == $config->infill_extruder-1) {
+            my $z = 1 * $self->Z;
+            $infill{$z} ||= [];
+            push @{$infill{$z}}, Slic3r::Line->new_scale(
+                    [ $self->X, $self->Y ],
+                    [ $info->{new_X}, $info->{new_Y} ],
+                    );
+            }
+            }
+            });
+    my $grow_d = scale($config->infill_extrusion_width)/2;
+    my $layer0_infill = union([ map @{$_->grow($grow_d)}, @{ $infill{0.2} } ]);
+    my $layer1_infill = union([ map @{$_->grow($grow_d)}, @{ $infill{0.4} } ]);
+    my $diff = diff($layer0_infill, $layer1_infill);
+    $diff = offset2_ex($diff, -$grow_d, +$grow_d);
+    $diff = [ grep { $_->area > 2*(($grow_d*2)**2) } @$diff ];
+    is scalar(@$diff), 0, 'no missing parts in solid shell when fill_density is 0';
+}
+
+{
+    # GH: #2697
+    my $config = Slic3r::Config->new_from_defaults;
+    $config->set('perimeter_extrusion_width', 0.72);
+    $config->set('top_infill_extrusion_width', 0.1);
+    $config->set('infill_extruder', 2);         # in order to distinguish infill
+        $config->set('solid_infill_extruder', 2);   # in order to distinguish infill
+
+        my $print = Slic3r::Test::init_print('20mm_cube', config => $config);
+    my %infill = ();  # Z => [ Line, Line ... ]
+        my %other  = ();  # Z => [ Line, Line ... ]
+        my $tool = undef;
+    Slic3r::GCode::Reader->new->parse(Slic3r::Test::gcode($print), sub {
+            my ($self, $cmd, $args, $info) = @_;
+
+            if ($cmd =~ /^T(\d+)/) {
+            $tool = $1;
+            } elsif ($cmd eq 'G1' && $info->{extruding} && $info->{dist_XY} > 0) {
+            my $z = 1 * $self->Z;
+            my $line = Slic3r::Line->new_scale(
+                    [ $self->X, $self->Y ],
+                    [ $info->{new_X}, $info->{new_Y} ],
+                    );
+            if ($tool == $config->infill_extruder-1) {
+            $infill{$z} //= [];
+            push @{$infill{$z}}, $line;
+            } else {
+            $other{$z} //= [];
+            push @{$other{$z}}, $line;
+            }
+            }
+            });
+    my $top_z = max(keys %infill);
+    my $top_infill_grow_d = scale($config->top_infill_extrusion_width)/2;
+    my $top_infill = union([ map @{$_->grow($top_infill_grow_d)}, @{ $infill{$top_z} } ]);
+    my $perimeters_grow_d = scale($config->perimeter_extrusion_width)/2;
+    my $perimeters = union([ map @{$_->grow($perimeters_grow_d)}, @{ $other{$top_z} } ]);
+    my $covered = union_ex([ @$top_infill, @$perimeters ]);
+    my @holes = map @{$_->holes}, @$covered;
+    ok sum(map unscale unscale $_->area*-1, @holes) < 1, 'no gaps between top solid infill and perimeters';
+}
+*/
+
 bool test_if_solid_surface_filled(const ExPolygon& expolygon, double flow_spacing, double angle, double density)
 {
     std::unique_ptr<Slic3r::Fill> filler(Slic3r::Fill::new_from_type("rectilinear"));
@@ -221,6 +498,18 @@ bool test_if_solid_surface_filled(const ExPolygon& expolygon, double flow_spacin
     const double scaled_flow_spacing = std::pow(scale_(flow_spacing), 2);
     uncovered.erase(std::remove_if(uncovered.begin(), uncovered.end(), [scaled_flow_spacing](const ExPolygon& poly) { return poly.area() < scaled_flow_spacing; }), uncovered.end());
 
+#if 0
+	if (! uncovered.empty()) {
+		BoundingBox bbox = get_extents(expolygon.contour);
+		bbox.merge(get_extents(uncovered));
+		bbox.merge(get_extents(grown_paths));
+		SVG svg("c:\\data\\temp\\test_if_solid_surface_filled.svg", bbox);
+		svg.draw(expolygon);
+		svg.draw(uncovered, "red");
+		svg.Close();
+	}
+#endif
+
     return uncovered.empty(); // solid surface is fully filled
 }
 

tests/fff_print/test_flow.cpp

@@ -58,6 +58,23 @@ SCENARIO("Flow math for non-bridges", "[Flow]") {
             }
         }
     }
+
+#if 0
+    /// Check for an edge case in the maths where the spacing could be 0; original
+    /// math is 0.99. Slic3r issue #4654
+    GIVEN("Input spacing of 0.414159 and a total width of 2") {
+        double in_spacing = 0.414159;
+        double total_width = 2.0;
+        auto flow = Flow::new_from_spacing(1.0, 0.4, 0.3);
+        WHEN("solid_spacing() is called") {
+            double result = flow.solid_spacing(total_width, in_spacing);
+            THEN("Yielded spacing is greater than 0") {
+                REQUIRE(result > 0);
+            }
+        }
+    }
+#endif    
+
 }
 
 /// Spacing, width calculation for bridge extrusions

tests/fff_print/test_gcodewriter.cpp

@@ -142,6 +142,21 @@ SCENARIO("z_hop lifts the nozzle when a lift is requested", "[GCodeWriter]") {
     }
 }
 
+SCENARIO("Origin manipulation", "[GCodeWriter]") {
+	Slic3r::GCode gcodegen;
+	WHEN("set_origin to (10,0)") {
+    	gcodegen.set_origin(Vec2d(10,0));
+    	REQUIRE(gcodegen.origin() == Vec2d(10, 0));
+    }
+	WHEN("set_origin to (10,0) and translate by (5, 5)") {
+		gcodegen.set_origin(Vec2d(10,0));
+		gcodegen.set_origin(gcodegen.origin() + Vec2d(5, 5));
+		THEN("origin returns reference to point") {
+    		REQUIRE(gcodegen.origin() == Vec2d(15,5));
+    	}
+    }
+}
+
 TEST_CASE("A cached config slot is looked up again whenever its key changes", "[GCodeWriter]")
 {
     GCode::ConfigIndexCache cache;

tests/fff_print/test_helpers.cpp

@@ -5,7 +5,6 @@
 #include "libslic3r/GCodeReader.hpp"
 #include "libslic3r/Config.hpp"
 #include "libslic3r/Print.hpp"
-#include "libslic3r/Model.hpp"
 
 #include <algorithm>
 #include <cstdlib>
@@ -503,3 +502,27 @@ std::vector<std::string> role_sequence(const std::string &gcode, const std::vect
 }
 
 } } // namespace Slic3r::Test
+
+#include <catch2/catch_all.hpp>
+#include "libslic3r/Arrange.hpp"
+#include "libslic3r/Model.hpp"
+
+SCENARIO("init_print functionality", "[test_helpers]") {
+	GIVEN("A default config") {
+		Slic3r::DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
+		WHEN("init_print is called with a single mesh.") {
+			Slic3r::Model model;
+			Slic3r::Print print;
+			Slic3r::Test::init_print({ Slic3r::Test::cube(20) }, print, model, config);
+			THEN("One mesh/printobject is in the resulting Print object.") {
+				REQUIRE(print.objects().size() == 1);
+			}
+			THEN("print.process() doesn't crash.") {
+				REQUIRE_NOTHROW(print.process());
+			}
+			THEN("Export gcode functions outputs text.") {
+				REQUIRE(! Slic3r::Test::gcode(print).empty());
+			}
+		}
+	}
+}

tests/fff_print/test_imex_mode_gcode.cpp

@@ -327,6 +327,24 @@ TEST_CASE("A printer with IMEX disabled resolves the mode placeholders to nothin
     CHECK_FALSE(has_line(gcode, kQuadScript));
 }
 
+// The placeholders are set unconditionally, ahead of the is_imex check, so they are defined for
+// every printer. A single-extruder preset that mentions {imex_mode} must expand it to an empty
+// string rather than fail the export on an unknown variable.
+TEST_CASE("IMEX mode placeholders are defined on an ordinary single-extruder printer",
+          "[ImexModeGcode][IMEX]")
+{
+    const std::string gcode = slice({ cube(20) }, {
+        { "skirt_loops",         "0" },
+        { "brim_type",           "no_brim" },
+        { "gcode_flavor",        "klipper" },
+        { "machine_start_gcode", kReportStartGcode },
+    });
+
+    CHECK(has_line(gcode, ";IMEX_MODE:"));
+    CHECK(has_line(gcode, ";IMEX_MODE_INDEX:0"));
+    CHECK(has_line(gcode, ";IMEX_MODE_GCODE:"));
+}
+
 // In a parallel mode no tool changes occur, so every active carriage has to be addressed
 // explicitly: once before the print for pressure advance, and again at the second layer for the
 // drop from the initial-layer temperature. Nothing else in the suite covers either emission, and

tests/fff_print/test_mixed_filament.cpp

@@ -66,6 +66,21 @@ void count_mixed(ToolOrdering &to, size_t &groups, size_t &resolutions)
 
 } // namespace
 
+TEST_CASE("enable_mixed_color_sublayer reaches the Print config", "[MixedFilament]")
+{
+    Print print;
+    Model model;
+    init_print({cube(20)}, print, model, mixed_config(true));
+
+    // The option lives in PrintConfig; if it did not survive Print::apply the slicer would
+    // silently fall back to the whole-layer path.
+    CHECK(print.config().enable_mixed_color_sublayer.value == true);
+    REQUIRE(print.config().filament_is_mixed.values.size() == 3);
+    CHECK(print.config().filament_is_mixed.values[2] == true);
+    REQUIRE(print.config().filament_mixed_components.values.size() == 3);
+    CHECK(print.config().filament_mixed_components.values[2] == "1,2");
+}
+
 TEST_CASE("Mixed filament splits layers into sub-layers when the option is on", "[MixedFilament]")
 {
     Print print;

tests/fff_print/test_multifilament.cpp

@@ -840,6 +840,32 @@ static void all_regions_on_filament(DynamicPrintConfig &config, int filament_1ba
         config.set_deserialize_strict({ { key, std::to_string(filament_1based) } });
 }
 
+// IMEX parallel modes emit per-carriage temperatures from a branch that is mutually
+// exclusive with the standard per-extruder path, and that branch skipped the head the
+// print's own toolpaths run on. That head therefore never received its 1st->2nd layer
+// transition and held nozzle_temperature_initial_layer for the whole job.
+TEST_CASE("Parallel-mode IMEX prints transition the printing head to its second-layer temperature",
+          "[MultiFilament][IMEX]")
+{
+    DynamicPrintConfig config = multifilament_config(7);
+    imex_7x4_printer(config);
+    all_regions_on_filament(config, 1); // filament 1 => logical slot 0 => physical head 0
+    // The multi-extruder normalization collapses per-filament temperature vectors to a
+    // single value, so heads are told apart by their tool qualifier, not by temperature.
+    config.set_deserialize_strict({
+        { "imex_parallel_mode",                "copy" },
+        { "nozzle_temperature_initial_layer",  "200" },
+        { "nozzle_temperature",                "240" },
+    });
+
+    const std::string gcode = slice({ cube(20) }, config);
+
+    // Head 0 runs the print's own toolpaths and must step 200 -> 240 at the second layer.
+    CHECK(gcode.find("M104 S240 T0") != std::string::npos);
+    // Head 1 is the copy carriage; it already worked and must keep working.
+    CHECK(gcode.find("M104 S240 T1") != std::string::npos);
+}
+
 // IMEX supplements is_extruder_used for the secondary carriages a parallel mode drives.
 // `primary` drives exactly one tool, so the supplement must not run: routing every region
 // to filament 6 puts the initial tool on physical head 2, while the mode's only declared

tests/fff_print/test_print.cpp

@@ -54,6 +54,8 @@
 #include <cstdlib>
 #include <sstream>
 #include <limits>
+#include <fstream>
+#include <iterator>
 #include <memory>
 #include <string_view>
 #include <utility>
@@ -792,6 +794,25 @@ TEST_CASE("Print statistics in custom G-code match the final print statistics",
     }
 }
 
+TEST_CASE("export_gcode writes G-code without a result pointer", "[Print][export_gcode]")
+{
+    Print print;
+    Model model;
+    Slic3r::Test::init_print({cube(20)}, print, model);
+    print.process();
+
+    SECTION("non-BBL printer") {}
+    SECTION("BBL printer") { print.is_BBL_printer() = true; }
+
+    ScopedTemporaryFile temp(".gcode");
+    REQUIRE_NOTHROW(print.export_gcode(temp.string(), nullptr, nullptr));
+
+    std::ifstream in(temp.string());
+    const std::string gcode((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+
+    REQUIRE_FALSE(gcode.empty());
+}
+
 TEST_CASE("Exporting a sliced print again gives the same G-code", "[Print][export_gcode][Regression]")
 {
     const int instances = GENERATE(1, 3);
@@ -1041,6 +1062,34 @@ TEST_CASE("Belt printers keep the part fan off within the band above the belt",
     CHECK(clear_fan_off == 0);
 }
 
+// Organic supports under an overhang on a belt printer reach below the object's first layer,
+// where the virtual belt raft layers sit at negative Z. The lowest of them used to get a
+// negative height and abort slicing with a negative flow error.
+TEST_CASE("Belt printers slice organic tree supports that reach the belt", "[Print][belt][Support]")
+{
+    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({
+        { "belt_printer",               1 },
+        { "belt_slice_rotation",        "x" },
+        { "belt_slice_rotation_angle",  45 },
+        { "gcode_remap_x",              "rev_x" },
+        { "gcode_remap_y",              "pos_z" },
+        { "gcode_remap_z",              "pos_y" },
+        { "layer_height",               0.2 },
+        { "initial_layer_print_height", 0.2 },
+        { "skirt_loops",                0 },
+        { "z_hop",                      0 },
+        { "enable_support",             1 },
+        { "support_type",               "tree(auto)" },
+        { "support_style",              "organic" },
+        { "machine_start_gcode",        "T[initial_tool]\n" },
+        { "layer_change_gcode",         "G92 E0\n" },
+    });
+    std::string gcode;
+    REQUIRE_NOTHROW(gcode = slice({ TestMesh::overhang }, config));
+    CHECK(! gcode.empty());
+}
+
 TEST_CASE("Slicing errors are reported per object with the object's name", "[Print]")
 {
     Print print;

tests/fff_print/test_skirt_brim.cpp

@@ -837,6 +837,30 @@ TEST_CASE("Belt brim on an object layer precedes its perimeters, once", "[SkirtB
     CHECK(role_passes(gc, "brim") <= bands);
 }
 
+// B - single extruder (filament id 1).  Every band must survive the 1-based -> 0-based
+// filament-id conversion the apron path performs: a wrong conversion drops all single-extruder
+// bands, so the pass count would collapse.  The expected count is derived from the sliced
+// layers, not a ratio.
+TEST_CASE("Belt brim on a single extruder emits every band once", "[SkirtBrim][belt]")
+{
+    DynamicPrintConfig config = belt_brim_config();
+    config.set_deserialize_strict({
+        { "brim_type",       "outer_only" },
+        { "brim_width",      4 },
+        { "brim_object_gap", 0 },
+    });
+    Print print;
+    Model model;
+    init_print({ cube(20) }, print, model, config);
+    const std::string gc = gcode(print);
+
+    const PrintObject &object = *print.objects().front();
+    const int expected = nonempty_belt_brim_layers(object) + belt_brim_apron_bands(object);
+    REQUIRE(expected > 0);
+    CHECK(role_layers(gc, "brim") == expected);
+    CHECK(belt_tools_for_role(gc, "brim") == std::set<int>{ 0 });   // filament 1 -> tool 0
+}
+
 // Number of brim segments the belt brim generator produced for `object`: the lattice
 // lines of every per-layer band plus the apron prologue.  Each segment is written as one
 // extruding move, so this is what a G-code count has to match.  A pass count cannot see a

tests/fff_print/test_slicing_pipeline_hook.cpp

@@ -27,6 +27,14 @@ TEST_CASE("slicing_pipeline_plugin option exists and defaults empty", "[slicing_
 
 #include "libslic3r/Print.hpp"
 
+TEST_CASE("slicing pipeline hook setter is a no-op-safe injection", "[slicing_pipeline]") {
+    int calls = 0;
+    Slic3r::Print::set_slicing_pipeline_hook_fn(
+        [&](Slic3r::Print&, const Slic3r::PrintObject*, Slic3r::SlicingPipelineStepPlugin){ ++calls; });
+    Slic3r::Print::set_slicing_pipeline_hook_fn(nullptr); // reset — must be legal
+    CHECK(calls == 0);
+}
+
 #include <vector>
 #include <algorithm>
 using namespace Slic3r::Test;

tests/fff_print/test_trianglemesh.cpp

@@ -10,6 +10,8 @@
 #include <cstdlib>
 #include <cstddef>
 #include <cmath>
+#include <future>
+#include <chrono>
 #include <vector>
 #include <math.h>
 #include "libslic3r/ExPolygon.hpp"
@@ -57,6 +59,12 @@ SCENARIO("Basic mesh statistics", "[TriangleMesh]") {
             REQUIRE(cube.facets_count() == facets.size());
         }
 
+#if 0
+        THEN( "Number of normals is equal to the number of facets.") {
+            REQUIRE(cube.normals().size() == facets.size());
+        }
+#endif
+
         THEN( "center() returns the center of the object.") {
             REQUIRE(cube.center() == Vec3d(10.0,10.0,10.0));
         }
@@ -257,6 +265,20 @@ SCENARIO("Split functionality", "[TriangleMesh]") {
     }
 }
 
+SCENARIO("Mesh merge functions", "[TriangleMesh]") {
+    GIVEN( "Two 20mm cubes, each with one corner on the origin") {
+		auto cube = make_cube();
+		TriangleMesh cube2(cube);
+
+        WHEN( "The two meshes are merged") {
+            cube.merge(cube2);
+            THEN( "There are twice as many facets in the merged mesh as the original.") {
+                REQUIRE(cube.facets_count() == 2 * cube2.facets_count());
+            }
+        }
+    }
+}
+
 SCENARIO("Cut behavior", "[TriangleMesh]") {
     GIVEN( "A 20mm cube with one corner on the origin") {
 		auto cube = make_cube();
@@ -284,3 +306,53 @@ SCENARIO("Cut behavior", "[TriangleMesh]") {
         }
     }
 }
+#ifdef TEST_PERFORMANCE
+TEST_CASE("Large mesh slices within the time budget (#4486)", "[TriangleMesh][Regression]") {
+    TriangleMesh mesh;
+    DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
+    mesh.ReadSTLFile(std::string(testfile_dir) + "test_trianglemesh/4486/100_000.stl");
+
+    config.set("layer_height", 500);
+    config.set("first_layer_height", 250);
+    config.set("nozzle_diameter", 500);
+
+    Slic3r::Print print;
+    Slic3r::Model model;
+    Slic3r::Test::init_print({mesh}, print, model, config);
+
+    print.status_cb = [] (int ln, const std::string& msg) { Slic3r::Log::info("Print") << ln << " " << msg << "\n";};
+
+    std::future<void> fut = std::async([&print] () { print.process(); });
+    std::chrono::milliseconds span {120000};
+    bool timedout {false};
+    if(fut.wait_for(span) == std::future_status::timeout) {
+        timedout = true;
+    }
+    REQUIRE(timedout == false);
+
+}
+#endif // TEST_PERFORMANCE
+
+#ifdef BUILD_PROFILE
+TEST_CASE("Large mesh slicing profile (#4486)", "[TriangleMesh][Profile]") {
+    TriangleMesh mesh;
+    DynamicPrintConfig config = Slic3r::DynamicPrintConfig::full_print_config();
+    mesh.ReadSTLFile(std::string(testfile_dir) + "test_trianglemesh/4486/10_000.stl");
+
+    config.set("layer_height", 500);
+    config.set("first_layer_height", 250);
+    config.set("nozzle_diameter", 500);
+    config.set("fill_density", "5%");
+
+    Slic3r::Print print;
+    Slic3r::Model model;
+    Slic3r::Test::init_print({mesh}, print, model, config);
+
+    print.status_cb = [] (int ln, const std::string& msg) { Slic3r::Log::info("Print") << ln << " " << msg << "\n";};
+
+    print.process();
+
+    REQUIRE(true);
+
+}
+#endif //BUILD_PROFILE

tests/fff_print/test_wipe.cpp

@@ -348,6 +348,21 @@ TEST_CASE("Inactive inward wipe settings preserve the exported trajectory", "[Wi
     CHECK_FALSE(trajectories_differ(regular_paths, inward_paths));
 }
 
+TEST_CASE("Inward wipe changes the exported trajectory when outer wall width is Auto", "[Wipe][Regression]")
+{
+    const char *wall_generator = GENERATE("classic", "arachne");
+    INFO("wall generator: " << wall_generator);
+
+    const std::vector<Vec2d> regular = wipe_destinations(
+        slice({make_cube(10., 10., 1.)}, wipe_config(wall_generator, false)));
+    const std::vector<Vec2d> inward = wipe_destinations(
+        slice({make_cube(10., 10., 1.)}, wipe_config(wall_generator, true)));
+
+    REQUIRE_FALSE(regular.empty());
+    REQUIRE_FALSE(inward.empty());
+    REQUIRE(trajectories_differ(regular, inward));
+}
+
 TEST_CASE("Inward wipe recognizes an external wall starting on an overhang", "[Wipe][Regression]")
 {
     const char *wall_generator = GENERATE("classic", "arachne");

tests/libslic3r/test_3mf.cpp

@@ -1647,6 +1647,69 @@ SCENARIO("Legacy 3MF without published metadata loads unchanged", "[3mf]") {
     }
 }
 
+// Locks the serialization contract of the orca_published_material_keys metadata: the per-entry JSON
+// must survive a store_bbs_3mf -> load_bbs_3mf round-trip verbatim, exactly like orca_published_keys.
+SCENARIO("Published 3MF round-trips the published_material_keys metadata", "[3mf]") {
+    GIVEN("a model carrying published material keys metadata") {
+        Model model;
+        std::string src_file = std::string(TEST_DATA_DIR) + "/test_3mf/Prusa.stl";
+        REQUIRE(load_stl(src_file.c_str(), &model));
+        model.add_default_instances();
+
+        const std::string material_keys_json =
+            R"([{"material":{"filament_type":"PLA","filament_vendor":"Generic","filament_id":"GFL99"},"slot":0,"keys":["filament_retraction_length","filament_z_hop"]}])";
+
+        model.model_info = std::make_shared<ModelInfo>();
+        model.model_info->metadata_items[ORCA_PUBLISHED_MATERIAL_TAG] = material_keys_json;
+
+        ScopedTemporaryDir backup_dir("orca_pub_mat");
+        model.set_backup_path(backup_dir.string());
+
+        WHEN("stored to and reloaded from a .3mf") {
+            ScopedTemporaryFile temp(".3mf");
+            const std::string test_file = temp.string();
+
+            DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+            StoreParams store_params;
+            store_params.path    = test_file.c_str();
+            store_params.model   = &model;
+            store_params.config  = &config;
+            store_params.strategy = SaveStrategy::Zip64 | SaveStrategy::Silence;
+            REQUIRE(store_bbs_3mf(store_params));
+
+            Model dst_model;
+            DynamicPrintConfig dst_config;
+            ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Enable };
+            PlateDataPtrs        dst_plates;
+            std::vector<Preset*> project_presets;
+            bool   is_bbl_3mf = false, is_orca_3mf = false;
+            Semver file_version;
+            bool loaded = load_bbs_3mf(test_file.c_str(), &dst_config, &ctxt, &dst_model, &dst_plates,
+                                       &project_presets, &is_bbl_3mf, &is_orca_3mf, &file_version, nullptr,
+                                       LoadStrategy::LoadModel | LoadStrategy::LoadConfig);
+            THEN("the published material keys metadata round-trips unchanged") {
+                REQUIRE(loaded);
+                REQUIRE(dst_model.model_info != nullptr);
+                REQUIRE(dst_model.model_info->metadata_items[ORCA_PUBLISHED_MATERIAL_TAG] == material_keys_json);
+
+                // The value must parse back to one material entry carrying the nested identity
+                // object, the author slot ordinal and the key list.
+                nlohmann::json entries = nlohmann::json::parse(material_keys_json);
+                REQUIRE(entries.is_array());
+                REQUIRE(entries.size() == 1);
+                REQUIRE(entries[0]["material"]["filament_type"] == "PLA");
+                REQUIRE(entries[0]["material"]["filament_vendor"] == "Generic");
+                REQUIRE(entries[0]["material"]["filament_id"] == "GFL99");
+                REQUIRE(entries[0]["slot"] == 0);
+                REQUIRE(entries[0]["keys"].is_array());
+                REQUIRE(entries[0]["keys"].size() == 2);
+                REQUIRE(entries[0]["keys"][0] == "filament_retraction_length");
+            }
+            release_PlateData_list(dst_plates);
+        }
+    }
+}
+
 SCENARIO("Minimal published 3MF omits project config, preset dumps and slicer tags", "[3mf]") {
     GIVEN("a multi-instance model carrying published metadata and a published_config payload") {
         Model model;

tests/libslic3r/test_arrange.cpp

@@ -159,6 +159,15 @@ TEST_CASE("overlap_area detects overlap and ignores touching edges", "[Arrange]"
     }
 }
 
+TEST_CASE("Arrange places every item on the physical bed", "[Arrange]")
+{
+    ArrangePolygons items = squares(5, 20.);
+    arrange(items, bed(200, 200), quiet_params(scaled(1.)));
+
+    for (const ArrangePolygon &ap : items)
+        REQUIRE(ap.bed_idx == 0);
+}
+
 TEST_CASE("Arranged items stay within the bed", "[Arrange]")
 {
     ArrangePolygons items = squares(6, 30.);

tests/libslic3r/test_caddocument.cpp

@@ -2061,6 +2061,49 @@ TEST_CASE("mass properties: invalid body index", "[CadDocument]")
     REQUIRE_FALSE(mp3.valid);
 }
 
+TEST_CASE("serialize_recipe roundtrip with two bodies", "[CadDocument]")
+{
+    using Catch::Matchers::WithinRel;
+    CadDocument doc;
+
+    // Body 1: rectangle sketch + extrude + fillet
+    int sk1 = doc.add_sketch(SketchShape::Rectangle, SketchPlane::XY(),
+                             20, 20, 10, "Rect1");
+    REQUIRE(sk1 >= 0);
+    doc.add_extrude(sk1, 10.0, false, BooleanMode::New, "Extrude1");
+    doc.add_fillet(2.0, FaceGroup::All, "Fillet1");
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    // Body 2: circle sketch + extrude (separate New body)
+    SketchEntity circ;
+    circ.type   = SketchEntity::Type::Circle;
+    circ.center = Vec2d(0, 0);
+    circ.radius = 8.0;
+    int sk2 = doc.add_sketch_entities({circ}, SketchPlane::XZ(), "Circle2");
+    doc.add_extrude(sk2, 6.0, false, BooleanMode::New, "Extrude2");
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    REQUIRE(doc.bodies.size() >= 2);
+    std::vector<double> orig_vols;
+    for (const auto& b : doc.bodies)
+        orig_vols.push_back(double(SketchEngine::tessellate(b.shape).volume()));
+
+    auto blob = doc.serialize_recipe();
+    REQUIRE_FALSE(blob.empty());
+
+    CadDocument doc2;
+    REQUIRE(doc2.deserialize_recipe(blob));
+    REQUIRE(doc2.error.empty());
+    REQUIRE(doc2.bodies.size() == doc.bodies.size());
+
+    for (size_t i = 0; i < doc.bodies.size(); ++i) {
+        double v2 = double(SketchEngine::tessellate(doc2.bodies[i].shape).volume());
+        REQUIRE_THAT(v2, WithinRel(orig_vols[i], 1e-6));
+    }
+}
+
 TEST_CASE("deserialize_recipe rejects future version with error", "[CadDocument]")
 {
     CadDocument doc;
@@ -2104,6 +2147,41 @@ TEST_CASE("deserialize_recipe handles empty blob without throwing", "[CadDocumen
     REQUIRE_FALSE(doc.error.empty());
 }
 
+TEST_CASE("deserialize_recipe error is non-empty on every failure path", "[CadDocument]")
+{
+    CadDocument doc;
+    auto reset = [&]() { doc = CadDocument{}; };
+
+    // too new
+    {
+        std::ostringstream oss;
+        { cereal::BinaryOutputArchive ar(oss); uint32_t v = 999; ar(v); }
+        reset();
+        REQUIRE_FALSE(doc.deserialize_recipe(oss.str()));
+        REQUIRE_FALSE(doc.error.empty());
+    }
+    // too old
+    {
+        std::ostringstream oss;
+        { cereal::BinaryOutputArchive ar(oss); uint32_t v = 1; ar(v); }
+        reset();
+        REQUIRE_FALSE(doc.deserialize_recipe(oss.str()));
+        REQUIRE_FALSE(doc.error.empty());
+    }
+    // truncated / garbage
+    {
+        reset();
+        REQUIRE_FALSE(doc.deserialize_recipe("not a valid blob \x00\x01\x02"));
+        REQUIRE_FALSE(doc.error.empty());
+    }
+    // empty
+    {
+        reset();
+        REQUIRE_FALSE(doc.deserialize_recipe(""));
+        REQUIRE_FALSE(doc.error.empty());
+    }
+}
+
 TEST_CASE("a v4 project still opens", "[CadDocument][recipe]")
 {
     // The regression guard for everyone who already has projects: a pre-framing v4
@@ -4131,6 +4209,25 @@ static CadDocument make_golden_doc_v1()
     return doc;
 }
 
+TEST_CASE("regenerate golden recipe fixture", "[.regen]")
+{
+    CadDocument doc = make_golden_doc_v1();
+    // ponytail: serialize_recipe() only needs features, recompute is unnecessary
+    // for a fixture that exercises the serialization format.
+    auto blob = doc.serialize_recipe();
+    REQUIRE_FALSE(blob.empty());
+
+    // Version-free on purpose: this writes whatever today's format is, so a version bump does
+    // not have to remember to edit it. The version-stamped fixtures beside it are frozen
+    // evidence from older builds and are never regenerated.
+    std::string path = std::string(TEST_DATA_DIR) + "/cad_recipe_current.bin";
+    std::ofstream ofs(path, std::ios::binary);
+    REQUIRE(ofs.is_open());
+    ofs.write(blob.data(), static_cast<std::streamsize>(blob.size()));
+    ofs.close();
+    SUCCEED("Fixture written to " << path);
+}
+
 // The previous format's real blob, kept on disk deliberately. It is the only thing that can
 // prove the version gate does its job: a v3 recipe carries FEWER fields per feature than this
 // build reads, so without the bump to v4 it would have passed the gate and had two ints read
@@ -5595,6 +5692,45 @@ TEST_CASE("surface-loft round-trip serialize/deserialize", "[CadDocument][surfac
 
 // --- Mate tests (M8a) ---
 
+TEST_CASE("fastened mate with zero offset/angle", "[CadDocument][mate]")
+{
+    using Catch::Matchers::WithinAbs;
+
+    CadDocument doc;
+    int sk_box = doc.add_sketch(SketchShape::Rectangle, SketchPlane::XY(), 10, 10, 0, "Box");
+    doc.add_extrude(sk_box, 5.0, false, BooleanMode::New, "BoxExt");
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    int cs_fixed = doc.add_coordsys(CoordSysType::PointWorld, Vec3d(5, 5, 5), "CS_Fixed");
+    doc.features[cs_fixed].coordsys_body = 0;
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    int sk_cyl = doc.add_sketch(SketchShape::Circle, SketchPlane::XY(), 0, 0, 3, "Cyl");
+    doc.add_extrude(sk_cyl, 10.0, false, BooleanMode::New, "CylExt");
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+    REQUIRE(doc.bodies.size() == 2);
+
+    int cs_moving = doc.add_coordsys(CoordSysType::PointWorld, Vec3d(0, 0, 5), "CS_Moving");
+    doc.features[cs_moving].coordsys_body = 1;
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    int mi = doc.add_mate(0, cs_fixed, cs_moving, 0.0, 0.0, false, "Mate");
+    REQUIRE(mi >= 0);
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    GProp_GProps props;
+    BRepGProp::VolumeProperties(doc.bodies[1].shape, props);
+    gp_Pnt com = props.CentreOfMass();
+    REQUIRE_THAT(double(com.X()), WithinAbs(5.0, 1e-4));
+    REQUIRE_THAT(double(com.Y()), WithinAbs(5.0, 1e-4));
+    REQUIRE_THAT(double(com.Z()), WithinAbs(5.0, 1e-4));
+}
+
 TEST_CASE("fastened mate with offset", "[CadDocument][mate]")
 {
     using Catch::Matchers::WithinAbs;
@@ -5791,6 +5927,30 @@ TEST_CASE("mate round-trip serialization", "[CadDocument][mate]")
     REQUIRE(mf->mate_flip   == true);
 }
 
+TEST_CASE("version 2 blob is rejected", "[CadDocument][mate]")
+{
+
+    CadDocument doc;
+    int sk = doc.add_sketch(SketchShape::Rectangle, SketchPlane::XY(), 10, 10, 0, "Box");
+    doc.add_extrude(sk, 5.0, false, BooleanMode::New, "E");
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+
+    std::ostringstream oss;
+    {
+        cereal::BinaryOutputArchive ar(oss);
+        uint32_t fake_v = 2;
+        ar(fake_v);
+        ar(doc.features);
+        ar(doc.variables);
+    }
+    std::string blob = oss.str();
+
+    CadDocument fresh;
+    REQUIRE_FALSE(fresh.deserialize_recipe(blob));
+    REQUIRE_CONTAINS(fresh.error, "older version");
+}
+
 TEST_CASE("mate error: out of range connectors", "[CadDocument][mate]")
 {
 
@@ -7533,6 +7693,17 @@ TEST_CASE("two holes are both subtracted", "[CadDocument][sketchwire]")
     REQUIRE_THAT(double(doc.display_mesh.volume()), Catch::Matchers::WithinRel(expected, 0.01));
 }
 
+TEST_CASE("a lone circle still extrudes exactly as before", "[CadDocument][sketchwire]")
+{
+    std::vector<SketchEntity> ents = { circle_entity({0, 0}, 8.0) };
+    CadDocument doc = plate_doc(ents, 5.0);
+
+    REQUIRE(doc.recompute());
+    REQUIRE(doc.error.empty());
+    const double expected = M_PI * 64.0 * 5.0;
+    REQUIRE_THAT(double(doc.display_mesh.volume()), Catch::Matchers::WithinRel(expected, 0.01));
+}
+
 TEST_CASE("a closed polygon still extrudes exactly as before", "[CadDocument][sketchwire]")
 {
     std::vector<SketchEntity> ents = rect_entities(20, 20);

tests/libslic3r/test_clipper_utils.cpp

@@ -155,6 +155,51 @@ SCENARIO("Various Clipper operations - xs/t/11_clipper.t", "[ClipperUtils]") {
             REQUIRE(result.front().length() == Catch::Approx(subject.length()));
         }
     }
+
+#if 0
+    {
+        # Clipper does not preserve polyline orientation
+        my $polyline = Slic3r::Polyline->new([50, 150], [300, 150]);
+        my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
+        is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
+        is_deeply $result->[0]->pp, [[100, 150], [200, 150]], 'clipped line orientation is preserved';
+    }
+    {
+        # Clipper does not preserve polyline orientation
+        my $polyline = Slic3r::Polyline->new([300, 150], [50, 150]);
+        my $result = Slic3r::Geometry::Clipper::intersection_pl([$polyline], [$square]);
+        is scalar(@$result), 1, 'intersection_pl - correct number of result lines';
+        is_deeply $result->[0]->pp, [[200, 150], [100, 150]], 'clipped line orientation is preserved';
+    }
+    {
+        # Disabled until Clipper bug #127 is fixed
+        my $subject = [
+            Slic3r::Polyline->new([-90000000, -100000000], [-90000000, 100000000]), # vertical
+                Slic3r::Polyline->new([-100000000, -10000000], [100000000, -10000000]), # horizontal
+                Slic3r::Polyline->new([-100000000, 0], [100000000, 0]), # horizontal
+                Slic3r::Polyline->new([-100000000, 10000000], [100000000, 10000000]), # horizontal
+        ];
+        my $clip = Slic3r::Polygon->new(# a circular, convex, polygon
+            [99452190, 10452846], [97814760, 20791169], [95105652, 30901699], [91354546, 40673664], [86602540, 50000000],
+            [80901699, 58778525], [74314483, 66913061], [66913061, 74314483], [58778525, 80901699], [50000000, 86602540],
+            [40673664, 91354546], [30901699, 95105652], [20791169, 97814760], [10452846, 99452190], [0, 100000000],
+            [-10452846, 99452190], [-20791169, 97814760], [-30901699, 95105652], [-40673664, 91354546],
+            [-50000000, 86602540], [-58778525, 80901699], [-66913061, 74314483], [-74314483, 66913061],
+            [-80901699, 58778525], [-86602540, 50000000], [-91354546, 40673664], [-95105652, 30901699],
+            [-97814760, 20791169], [-99452190, 10452846], [-100000000, 0], [-99452190, -10452846],
+            [-97814760, -20791169], [-95105652, -30901699], [-91354546, -40673664], [-86602540, -50000000],
+            [-80901699, -58778525], [-74314483, -66913061], [-66913061, -74314483], [-58778525, -80901699],
+            [-50000000, -86602540], [-40673664, -91354546], [-30901699, -95105652], [-20791169, -97814760],
+            [-10452846, -99452190], [0, -100000000], [10452846, -99452190], [20791169, -97814760],
+            [30901699, -95105652], [40673664, -91354546], [50000000, -86602540], [58778525, -80901699],
+            [66913061, -74314483], [74314483, -66913061], [80901699, -58778525], [86602540, -50000000],
+            [91354546, -40673664], [95105652, -30901699], [97814760, -20791169], [99452190, -10452846], [100000000, 0]
+            );
+        my $result = Slic3r::Geometry::Clipper::intersection_pl($subject, [$clip]);
+        is scalar(@$result), scalar(@$subject), 'intersection_pl - expected number of polylines';
+        is sum(map scalar(@$_), @$result), scalar(@$subject) * 2, 'intersection_pl - expected number of points in polylines';
+    }
+#endif
 }
 
 SCENARIO("Various Clipper operations - t/clipper.t", "[ClipperUtils]") {

tests/libslic3r/test_config.cpp

@@ -643,6 +643,45 @@ SCENARIO("update_non_diff_values_to_base_config keeps a project's changed values
     }
 }
 
+// SCENARIO("DynamicPrintConfig JSON serialization", "[Config]") {
+//     WHEN("DynamicPrintConfig is serialized and deserialized") {
+// 	auto now = std::chrono::high_resolution_clock::now();
+// 	auto timestamp = now.time_since_epoch().count();
+// 	std::stringstream ss;
+// 	ss << "catch_test_serialization_" << timestamp << ".json";
+// 	std::string filename = (fs::temp_directory_path() / ss.str()).string();
+
+// TODO: Finish making a unit test for JSON serialization
+//         FullPrintConfig full_print_config;
+//         DynamicPrintConfig cfg;
+//         cfg.apply(full_print_config, false);
+
+//         std::string serialized;
+//         try {
+//             std::ostringstream ss;
+//             cereal::BinaryOutputArchive oarchive(ss);
+//             oarchive(cfg);
+//             serialized = ss.str();
+//         } catch (const std::runtime_error & /* e */) {
+//             // e.what();
+//         }
+// 	CAPTURE(serialized.length());
+
+//         THEN("Config object contains ini file options.") {
+//             DynamicPrintConfig cfg2;
+//             try {
+//                 std::stringstream ss(serialized);
+//                 cereal::BinaryInputArchive iarchive(ss);
+//                 iarchive(cfg2);
+//             } catch (const std::runtime_error & /* e */) {
+//                 // e.what();
+//             }
+// 	    CAPTURE(cfg.diff_report(cfg2));
+//             REQUIRE(cfg == cfg2);
+//         }
+//     }
+// }
+
 TEST_CASE("save_to_json round-trips plugin capability references as strings", "[Config][plugins]") {
     ScopedTemporaryFile tmp(".json");
     const std::vector<std::string> refs = {

tests/libslic3r/test_elephant_foot_compensation.cpp

@@ -17,6 +17,10 @@ using namespace Slic3r;
 
 // #define TESTS_EXPORT_SVGS
 
+namespace Slic3r {
+	Points mittered_offset_path_scaled(const Points& contour, const std::vector<float>& deltas, double miter_limit);
+}
+
 static ExPolygon spirograph_gear_1mm()
 {
 	ExPolygon out;
@@ -475,6 +479,33 @@ SCENARIO("Elephant foot compensation", "[ElephantFoot]") {
         }
 	}
 
+#if 0
+	GIVEN("Varying inner offset") {
+		ExPolygon input = spirograph_gear_1mm().simplify(SCALED_EPSILON).front();
+		ExPolygon output;
+		std::vector<float> deltas(input.contour.points.size(), scale_(1.));
+                // mittered_offset_path_scaled_points is commented out somewhere above
+		output.contour.points = Slic3r::mittered_offset_path_scaled_points(input.contour.points, deltas, 2.);
+#ifdef TESTS_EXPORT_SVGS
+		{
+			SVG svg(debug_out_path("elephant_foot_compensation_0.svg").c_str(), get_extents(output));
+			svg.draw(input, "blue");
+			svg.draw_outline(output, "black", coord_t(scale_(0.01)));
+		}
+#endif /* TESTS_EXPORT_SVGS */
+		for (size_t i = 0; i <= deltas.size() / 2; ++ i)
+			deltas[i] = deltas[deltas.size() - i - 1] = scale_(1.) * double(i) / (0.5 * double(deltas.size()));
+		output.contour.points = Slic3r::mittered_offset_path_scaled_points(input.contour.points, deltas, 2.);
+#ifdef TESTS_EXPORT_SVGS
+		{
+			SVG svg(debug_out_path("elephant_foot_compensation_varying.svg").c_str(), get_extents(output));
+			svg.draw(input, "blue");
+			svg.draw_outline(output, "black", coord_t(scale_(0.01)));
+		}
+#endif /* TESTS_EXPORT_SVGS */
+	}
+#endif
+
     GIVEN("Rectangle with a narrow part sticking out") {				
 		// Rectangle
 		ExPolygon expoly;

tests/libslic3r/test_fill_plane_path.cpp

@@ -208,3 +208,20 @@ TEST_CASE("Octagram spiral smooth factor controls corner curvature", "[FillPlane
     REQUIRE(path_length(half_smooth) < path_length(sharp));
     REQUIRE(invalid_factor == sharp);
 }
+
+TEST_CASE("Hilbert curve smooth factor controls corner curvature", "[FillPlanePath]")
+{
+    const Points sharp       = TestableHilbertCurve().generate_points(0.005);
+    const Points half_smooth = TestableHilbertCurve().generate_points(0.005, 0.5);
+    const Points full_smooth = TestableHilbertCurve().generate_points(0.005, 1.);
+    const Points invalid_factor = TestableHilbertCurve().generate_points(
+        0.005, std::numeric_limits<double>::quiet_NaN());
+
+    REQUIRE(full_smooth.front() == half_smooth.front());
+    REQUIRE(full_smooth.back() == half_smooth.back());
+    REQUIRE(path_length(full_smooth) < path_length(half_smooth));
+    REQUIRE(invalid_factor == sharp);
+
+    for (size_t i = 1; i < full_smooth.size(); ++i)
+        REQUIRE((full_smooth[i] - full_smooth[i - 1]).squaredNorm() > 0);
+}

tests/libslic3r/test_geometry.cpp

@@ -18,6 +18,8 @@
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ShortestPath.hpp"
 
+//#include <random>
+//#include "libnest2d/tools/benchmark.h"
 #include "libslic3r/SVG.hpp"
 
 #include "../libnest2d/printer_parts.hpp"
@@ -603,6 +605,73 @@ TEST_CASE("Convex polygon intersection on two overlapping squares", "[Geometry][
     REQUIRE(is_inters == true);
 }
 
+//// Only for benchmarking
+//static Polygon gen_convex_poly(std::mt19937_64 &rg, size_t point_cnt)
+//{
+//    std::uniform_int_distribution<coord_t> dist(0, 100);
+
+//    Polygon out;
+//    out.points.reserve(point_cnt);
+
+//    coord_t tr = dist(rg) * 2 / SCALING_FACTOR;
+
+//    for (size_t i = 0; i < point_cnt; ++i)
+//        out.points.emplace_back(tr + dist(rg) / SCALING_FACTOR,
+//                                tr + dist(rg) / SCALING_FACTOR);
+
+//    return Geometry::convex_hull(out.points);
+//}
+//TEST_CASE("Convex polygon intersection test on random polygons", "[Geometry]") {
+//    constexpr size_t TEST_CNT = 1000;
+//    constexpr size_t POINT_CNT = 1000;
+
+//    auto seed = std::random_device{}();
+////    unsigned long seed = 2525634386;
+//    std::mt19937_64 rg{seed};
+//    Benchmark bench;
+
+//    auto tests = reserve_vector<std::pair<Polygon, Polygon>>(TEST_CNT);
+//    auto results = reserve_vector<bool>(TEST_CNT);
+//    auto expects = reserve_vector<bool>(TEST_CNT);
+
+//    for (size_t i = 0; i < TEST_CNT; ++i) {
+//        tests.emplace_back(gen_convex_poly(rg, POINT_CNT), gen_convex_poly(rg, POINT_CNT));
+//    }
+
+//    bench.start();
+//    for (const auto &test : tests)
+//        results.emplace_back(Geometry::convex_polygons_intersect(test.first, test.second));
+//    bench.stop();
+
+//    std::cout << "Test time: " << bench.getElapsedSec() << std::endl;
+
+//    bench.start();
+//    for (const auto &test : tests)
+//        expects.emplace_back(!intersection(test.first, test.second).empty());
+//    bench.stop();
+
+//    std::cout << "Clipper time: " << bench.getElapsedSec() << std::endl;
+
+//    REQUIRE(results.size() == expects.size());
+
+//    auto seedstr = std::to_string(seed);
+//    for (size_t i = 0; i < results.size(); ++i) {
+//        // std::cout << expects[i] << " ";
+
+//        if (results[i] != expects[i]) {
+//            SVG svg{std::string("fail_seed") + seedstr + "_" + std::to_string(i) + ".svg"};
+//            svg.draw(tests[i].first, "blue");
+//            svg.draw(tests[i].second, "green");
+//            svg.Close();
+
+//            // std::cout << std::endl;
+//        }
+//        REQUIRE(results[i] == expects[i]);
+//    }
+//    std::cout << std::endl;
+
+//}
+
 struct Pair
 {
     size_t first, second;

tests/libslic3r/test_imex_helpers.cpp

@@ -71,6 +71,15 @@ TEST_CASE("effective_physical_extruder_map - degenerate nozzle count still yield
     REQUIRE(effective_physical_extruder_map(nullptr, 0).values == std::vector<int>{0});
 }
 
+TEST_CASE("effective_physical_extruder_map - IDEX ghost-color regression guard", "[IMEX]") {
+    // Dual extruder, no authored map. Before the GUI fix this produced a black ghost on T1
+    // because first_filament_for_physical_head({0}, 1) == -1.
+    auto default_pem = make_pem({0});
+    auto pem         = effective_physical_extruder_map(&default_pem, 2);
+    REQUIRE(first_filament_for_physical_head(pem, 0) == 0);
+    REQUIRE(first_filament_for_physical_head(pem, 1) == 1); // no longer -1
+}
+
 TEST_CASE("imex_pem_tool_for - non-parallel mode returns -1", "[IMEX]") {
     // Empty mode string (not in IMEX) and "primary" (IMEX present but not parallel) both
     // short-circuit to bare-firmware PA/temp emission.
@@ -1049,6 +1058,12 @@ TEST_CASE("compute_imex_slice_offset - flag on + copy mode returns primary zone
     REQUIRE_THAT(z.y(), WithinAbs(40.0, 1e-9));
 }
 
+TEST_CASE("compute_imex_slice_offset - flag on + mirror mode returns primary zone center", "[IMEX]") {
+    auto z = compute_imex_slice_offset(true, "mirror", kPrimaryZoneCenteredAt60_40);
+    REQUIRE_THAT(z.x(), WithinAbs(60.0, 1e-9));
+    REQUIRE_THAT(z.y(), WithinAbs(40.0, 1e-9));
+}
+
 TEST_CASE("compute_imex_slice_offset - user-defined non-primary mode names trigger shift", "[IMEX]") {
     // Mode names are user-defined; anything not "primary" or "" should activate.
     auto z = compute_imex_slice_offset(true, "iq-copy", kPrimaryZoneCenteredAt60_40);

tests/libslic3r/test_indexed_triangle_set.cpp

@@ -6,6 +6,7 @@
 #include "libslic3r/Point.hpp"
 #include "libslic3r/libslic3r.h"
 #include <limits>
+#include <random>
 #include <catch2/catch_all.hpp>
 #include <vector>
 #include <string>
@@ -116,6 +117,68 @@ TEST_CASE("Split two watertight meshes", "[its_split][its]") {
 }
 
 #include <libslic3r/QuadricEdgeCollapse.hpp>
+static float triangle_area(const Vec3f &v0, const Vec3f &v1, const Vec3f &v2)
+{
+    Vec3f ab = v1 - v0;
+    Vec3f ac = v2 - v0;
+    return ab.cross(ac).norm() / 2.f;
+}
+
+static float triangle_area(const stl_triangle_vertex_indices &triangle_indices, const std::vector<Vec3f> &vertices)
+{
+    return triangle_area(vertices[triangle_indices[0]],
+                         vertices[triangle_indices[1]],
+                         vertices[triangle_indices[2]]);
+}
+
+#if 0
+// clang complains about unused functions
+static std::mt19937 create_random_generator() {
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    return gen;
+}
+#endif
+
+std::vector<Vec3f> its_sample_surface(const indexed_triangle_set &its,
+                                      double        sample_per_mm2,
+                                      std::mt19937 random_generator) // = create_random_generator())
+{
+    std::vector<Vec3f> samples;
+    std::uniform_real_distribution<float> rand01(0.f, 1.f);
+    for (const auto &triangle_indices : its.indices) {
+        float area = triangle_area(triangle_indices, its.vertices);
+        float countf;
+        float fractional = std::modf(area * sample_per_mm2, &countf);
+        int count = static_cast<int>(countf);
+
+        float generate = rand01(random_generator);
+        if (generate < fractional) ++count;
+        if (count == 0) continue;
+
+        const Vec3f &v0 = its.vertices[triangle_indices[0]];
+        const Vec3f &v1 = its.vertices[triangle_indices[1]];
+        const Vec3f &v2 = its.vertices[triangle_indices[2]];
+        for (int c = 0; c < count; c++) {
+            // barycentric coordinate
+            Vec3f b;
+            b[0] = rand01(random_generator);
+            b[1] = rand01(random_generator);
+            if ((b[0] + b[1]) > 1.f) {
+                b[0] = 1.f - b[0];
+                b[1] = 1.f - b[1];
+            }
+            b[2] = 1.f - b[0] - b[1];
+            Vec3f pos;
+            for (int i = 0; i < 3; i++) {
+                pos[i] = b[0] * v0[i] + b[1] * v1[i] + b[2] * v2[i];
+            }
+            samples.push_back(pos);
+        }        
+    }
+    return samples;
+}
+
 
 #include "libslic3r/AABBTreeIndirect.hpp"
 

tests/libslic3r/test_ordering_strategies.cpp

@@ -261,6 +261,16 @@ TEST_CASE("snake_core produces valid paths on ring", "[Snake]") {
     REQUIRE(is_permutation(p2, centers.size()));
 }
 
+// --- Core Strategy Tests: Random Layout ---
+
+TEST_CASE("snake_core produces valid paths on random input", "[Snake]") {
+    Points centers = make_random_16();
+
+    auto p2 = snake_core(centers);
+
+    REQUIRE(is_permutation(p2, centers.size()));
+}
+
 // --- Quality Comparison Tests ---
 
 TEST_CASE("snake has no crossings on random input", "[Snake]") {

tests/libslic3r/test_precise_seam.cpp

@@ -730,6 +730,25 @@ TEST_CASE("Neighboring vertices distinguish repeated anchors on different lobes"
     CHECK(edges == std::vector<size_t>{0, 2, 3, 4, 6, 7});
 }
 
+TEST_CASE("Modifier holes subtract coverage while separate components add intervals", "[PreciseSeam][SegmentExtraction]")
+{
+    const Polygon perimeter = rectangle(0, 0, 20, 20);
+    ExPolygon area(rectangle(1, -3, 10, 3));
+    area.holes.push_back(rectangle(4, -1, 7, 1));
+    area.holes.back().reverse();
+    const auto result = PreciseSeam::extract_perimeter_segments(PreciseSeam::PreparedPerimeter(perimeter),
+        PreciseSeam::prepare_modifier_regions({area, ExPolygon(rectangle(14, -3, 18, 3))}), ModelVolumeType::PRECISE_SEAM_CENTER);
+    check_provenance(perimeter, result);
+    REQUIRE(result.segments.size() == 3);
+    const std::vector<Point> starts{mm(1, 0), mm(7, 0), mm(14, 0)};
+    const std::vector<Point> ends{mm(4, 0), mm(10, 0), mm(18, 0)};
+    for (size_t i = 0; i < 3; ++i) {
+        CHECK(result.segments[i].polyline.points.front() == starts[i]);
+        CHECK(result.segments[i].polyline.points.back() == ends[i]);
+    }
+    CHECK_FALSE(result.full_containment);
+}
+
 TEST_CASE("Full coverage is distinct from an empty or point-only intersection", "[PreciseSeam][SegmentExtraction]")
 {
     const bool reverse = GENERATE(false, true);

tests/libslic3r/test_preset_bundle_loading.cpp

@@ -1219,24 +1219,6 @@ TEST_CASE("find_preset2 auto-matches removed Generic vendor profiles to the libr
     CHECK(bundle.filaments.find_preset2("BrandX Generic PETG", /*auto_match=*/true) == nullptr);
 }
 
-TEST_CASE("The selected preset is its own base when its parent is not loaded", "[Preset]")
-{
-    PresetCollection printers(Preset::TYPE_PRINTER, Preset::printer_options(),
-                              static_cast<const PrintRegionConfig &>(FullPrintConfig::defaults()));
-    add_inmemory_preset(printers, "Printer");
-    add_inmemory_preset(printers, "User Printer", "Printer");
-    add_inmemory_preset(printers, "Orphan Printer", "Uninstalled Vendor Printer");
-
-    printers.select_preset_by_name("User Printer", true);
-    REQUIRE(printers.get_selected_preset_name() == "User Printer");
-    CHECK(printers.get_selected_preset_base().name == "Printer");
-
-    printers.select_preset_by_name("Orphan Printer", true);
-    REQUIRE(printers.get_selected_preset_name() == "Orphan Printer");
-    REQUIRE(printers.get_preset_base(printers.get_selected_preset()) == nullptr);
-    CHECK(printers.get_selected_preset_base().name == "Orphan Printer");
-}
-
 TEST_CASE("Renamed parent is normalized into a loaded preset's inherits", "[Preset][Rename]")
 {
     ScopedTemporaryDir   temp_dir;

tests/libslic3r/test_sketchconstraints.cpp

@@ -239,6 +239,30 @@ TEST_CASE("DistanceX on two Points binds real roles with non-negative prefill",
     REQUIRE(p.defs[0].eb == 0);
 }
 
+TEST_CASE("Horizontal on a Point rejects with NeedALine", "[SketchConstraints]")
+{
+    std::vector<SketchEntity> ents = { mk_point(1, 2) };
+    ConstraintPlan p = plan_entity_constraint(ents, 0, -1, -1, SketchConstraintType::Horizontal);
+    REQUIRE(p.kind == ConstraintPlan::Kind::Reject);
+    REQUIRE(p.reason == ConstraintReject::NeedALine);
+}
+
+TEST_CASE("Angle on two Circles rejects with NeedTwoLines", "[SketchConstraints]")
+{
+    std::vector<SketchEntity> ents = { mk_circle(0, 0, 1), mk_circle(5, 0, 1) };
+    ConstraintPlan p = plan_entity_constraint(ents, 0, 1, -1, SketchConstraintType::Angle);
+    REQUIRE(p.kind == ConstraintPlan::Kind::Reject);
+    REQUIRE(p.reason == ConstraintReject::NeedTwoLines);
+}
+
+TEST_CASE("Parallel on a Line + Circle rejects with NeedTwoLines (new guard)", "[SketchConstraints]")
+{
+    std::vector<SketchEntity> ents = { mk_line(0, 0, 1, 0), mk_circle(5, 0, 1) };
+    ConstraintPlan p = plan_entity_constraint(ents, 0, 1, -1, SketchConstraintType::Parallel);
+    REQUIRE(p.kind == ConstraintPlan::Kind::Reject);
+    REQUIRE(p.reason == ConstraintReject::NeedTwoLines);
+}
+
 TEST_CASE("Equal on two Circles promotes to EqualRadius", "[SketchConstraints]")
 {
     std::vector<SketchEntity> ents = { mk_circle(0, 0, 1), mk_circle(5, 0, 2) };

tests/libslic3r/test_stl.cpp

@@ -44,6 +44,17 @@ SCENARIO("Reading an STL file", "[stl]") {
 				REQUIRE(is_approx(model.objects.front()->volumes.front()->mesh().size(), Vec3d(20, 20, 20)));
 			}
 		}
+#if 0
+		// ASCII STLs ending with just carriage returns are not supported. These were used by the old Macs, while the Unix based MacOS uses LFs as any other Unix.
+		WHEN("line endings CR") {
+			Slic3r::Model model;
+			THEN("load should succeed") {
+				REQUIRE(Slic3r::load_stl(stl_path("ASCII/20mmbox-CR.stl").c_str(), &model));
+				REQUIRE(is_approx(model.objects.front()->volumes.front()->mesh().size(), Vec3d(20, 20, 20)));
+			}
+		}
+
+#endif
 		WHEN("nonstandard STL file (text after ending tags, invalid normals, for example infinities)") {
 			Slic3r::Model model;
 			THEN("load should succeed") {

tests/libslic3r/test_texture_displacement.cpp

@@ -3285,6 +3285,33 @@ TEST_CASE("a ModelUV layer falls back to Triplanar when the volume carries no UV
         CHECK_THAT((no_channel.vertices[i] - as_triplanar.vertices[i]).norm(), WithinAbs(0.f, 1e-5f));
 }
 
+TEST_CASE("a bake with colour off on every layer reports no colour at all", "[TextureDisplacement]")
+{
+    const indexed_triangle_set cube = its_make_cube(10., 10., 10.);
+
+    TextureDisplacementLayer layer;
+    layer.slot          = 0;
+    layer.depth_mm      = 1.0f;
+    layer.tiling_scale  = 5.0f;
+    layer.image_data    = make_flat_rgb_png(200, 40, 10); // has colour to give...
+    layer.color_enabled = false;                          // ...but is not asked for it
+
+    TextureDisplacementFacetsData facets{};
+    facets[0] = paint_whole_mesh(cube);
+
+    std::vector<uint8_t> triangle_color;
+    TextureColorRequest  request;
+    request.quantize     = [](const Vec3f &) { return 0; }; // would colour everything, if asked
+    request.out_triangle = &triangle_color;
+
+    const indexed_triangle_set out = build_texture_displacement(cube, {layer}, facets, classic_options(), {}, &request);
+    REQUIRE_FALSE(out.vertices.empty());
+    // Every entry 0 ("this triangle takes no colour from the texture"), so the commit leaves whatever
+    // the model was already painted with exactly as it was.
+    for (const uint8_t entry : triangle_color)
+        CHECK(entry == 0);
+}
+
 TEST_CASE("transfer_uv_channel resamples a UV channel onto a subdivided copy of the same surface",
           "[TextureDisplacement]")
 {

tests/libslic3r/test_vendor_cache.cpp

@@ -1110,6 +1110,28 @@ TEST_CASE("a cache with the wrong cache version is rejected", "[VendorCache]")
     REQUIRE(!out.load_vendor_cache(cache.string(), vid, Semver("1.0.0")));
 }
 
+TEST_CASE("a cache truncated mid-blob is rejected", "[VendorCache]")
+{
+    TempDir           tmp;
+    const std::string vid   = "Acme";
+    const fs::path     cache = tmp.path / "vendor.opc";
+
+    REQUIRE(save_one_vendor(cache.string(), one_vendor(vid), vid, "1.0.0",
+                            {filament_entry(vid + " PLA")}));
+
+    {
+        std::ifstream in(cache.string(), std::ios::binary);
+        std::vector<char> buf(30); // 20-byte header + 10 bytes of blob
+        in.read(buf.data(), 30);
+        in.close();
+        std::ofstream out(cache.string(), std::ios::binary | std::ios::trunc);
+        out.write(buf.data(), 30);
+    }
+
+    PresetBundle out;
+    REQUIRE(!out.load_vendor_cache(cache.string(), vid, Semver("1.0.0")));
+}
+
 TEST_CASE("printer model bed texture fields survive a cache round-trip", "[VendorCache]")
 {
     TempDir           tmp;

tests/libslic3r/test_voronoi.cpp

@@ -34,6 +34,53 @@ using namespace Slic3r;
 using VD = Geometry::VoronoiDiagram;
 using BoostVD = boost::polygon::voronoi_diagram<double>;
 
+// https://svn.boost.org/trac10/ticket/12067
+// This bug seems to be confirmed.
+// Vojtech supposes that there may be no Voronoi edges produced for
+// the 1st and last sweep line positions.
+TEST_CASE("Voronoi missing edges - points 12067", "[Voronoi]")
+{
+    Points pts {
+        { -10, -20 },
+        {  10, -20 },
+        {   5,   0 },
+        {  10,  20 },
+        { -10,  20 },
+        {  -5,   0 }
+    };
+
+#if 0
+    for (Point &p : pts) {
+        Vec2d q = p.cast<double>();
+        p.x() = scale_(p.x());
+        p.y() = scale_(p.y());
+    }
+#endif
+
+#if 0
+    // Try to rotate, maybe the issue is caused by incorrect handling of vertical or horizontal edges?
+    double a = 0.18764587962597876897475f;
+    double c = cos(a);
+    double s = sin(a);
+    for (Point &p : poly.points) {
+        Vec2d q = p.cast<double>();
+        p.x() = coord_t(q.x() * c + q.y() * s + 0.5);
+        p.y() = coord_t(- q.x() * s + q.y() * c + 0.5);
+    }
+#endif
+
+    // Construction of the Voronoi Diagram.
+    BoostVD vd;
+    construct_voronoi(pts.begin(), pts.end(), &vd);
+
+#ifdef VORONOI_DEBUG_OUT
+    dump_voronoi_to_svg(debug_out_path("voronoi-pts.svg").c_str(),
+        vd, pts, Lines());
+#endif
+
+//    REQUIRE(closest_point.z() == Catch::Approx(1.));
+}
+
 // https://svn.boost.org/trac10/ticket/12707
 // This issue is confirmed, there are no self intersections in the polygon.
 // A minimal test case is created at the end of this test,
@@ -268,6 +315,36 @@ TEST_CASE("Voronoi weirdness", "[Voronoi]")
 #endif
 }
 
+// https://svn.boost.org/trac10/ticket/12903
+// division by zero reported, but this issue is most likely a non-issue, as it produces an infinity for the interval of validity
+// of the floating point calculation, therefore forcing a recalculation with extended accuracy.
+TEST_CASE("Voronoi division by zero 12903", "[Voronoi]")
+{
+    Points pts { { 1, 1 }, { 3, 1 }, { 1, 3 }, { 3, 3 },
+                 { -1, 1 }, { 1, -1 }, { 5, 1 }, { 3, -1 },
+                 { -1, 3 }, { 1, 5 }, { 5, 3 }, { 3, 5 } };
+    {
+        auto pts2 { pts };
+        std::sort(pts2.begin(), pts2.end(), [](auto &l, auto &r) { return (l.x() == r.x()) ? l.y() < r.y() : l.x() < r.x(); });
+        // No point removed -> no duplicate.
+        REQUIRE(std::unique(pts2.begin(), pts2.end()) == pts2.end());
+    }
+
+    BoostVD vd;
+    construct_voronoi(pts.begin(), pts.end(), &vd);
+
+#ifdef VORONOI_DEBUG_OUT
+    // Scale the voronoi vertices and input points, so that the dump_voronoi_to_svg will display them correctly.
+    for (auto &pt : vd.vertices()) {
+        const_cast<double&>(pt.x()) = scale_(pt.x());
+        const_cast<double&>(pt.y()) = scale_(pt.y());
+    }
+    for (auto &pt : pts)
+        pt = Point::new_scale(pt.x(), pt.y());
+    dump_voronoi_to_svg(debug_out_path("voronoi-div-by-zero.svg").c_str(), vd, pts, Lines());
+#endif
+}
+
 // https://svn.boost.org/trac10/ticket/12139
 // Funny sample from a dental industry?
 // Vojtech confirms this test fails and rightly so, because the input data contain self intersections.
@@ -1306,6 +1383,15 @@ TEST_CASE("Voronoi offset", "[VoronoiOffset]")
             OffsetTest { scale_(0.55), 1, 0 }
       }) {
 
+#if 0
+      Polygons offsetted_polygons_out = Slic3r::Voronoi::offset(vd, lines, ot.distance, scale_(0.005));
+#ifdef VORONOI_DEBUG_OUT
+      dump_voronoi_to_svg(debug_out_path("voronoi-offset-out-%lf.svg", ot.distance).c_str(),
+          vd, Points(), lines, offsetted_polygons_out);
+#endif
+      REQUIRE(offsetted_polygons_out.size() == ot.num_outer);
+#endif
+
       Polygons offsetted_polygons_in = Slic3r::Voronoi::offset(vd, lines, - ot.distance, scale_(0.005));
 #ifdef VORONOI_DEBUG_OUT
       dump_voronoi_to_svg(debug_out_path("voronoi-offset-in-%lf.svg", ot.distance).c_str(),

tests/slic3rutils/CMakeLists.txt

@@ -30,6 +30,7 @@ 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_resource_texture.cpp

tests/slic3rutils/slic3rutils_tests_main.cpp

@@ -1 +1,61 @@
 #include <catch2/catch_all.hpp>
+
+#include <catch2/catch_test_macros.hpp>
+#include "slic3r/Utils/Http.hpp"
+
+TEST_CASE("Check SSL certificates paths", "[Http][NotWorking]") {
+    
+    Slic3r::Http g = Slic3r::Http::get("https://github.com/");
+    
+    unsigned status = 0;
+    g.on_error([&status](std::string, std::string, unsigned http_status) {
+        status = http_status;
+    });
+    
+    g.on_complete([&status](std::string /* body */, unsigned http_status){
+        status = http_status;
+    });
+    
+    g.perform_sync();
+    
+    REQUIRE(status == 200);
+}
+
+TEST_CASE("Http digest authentication", "[Http][NotWorking]") {
+    Slic3r::Http g = Slic3r::Http::get("https://httpbingo.org/digest-auth/auth/guest/guest");
+
+    g.auth_digest("guest", "guest");
+
+    unsigned status = 0;
+    g.on_error([&status](std::string, std::string, unsigned http_status) {
+        status = http_status;
+    });
+
+    g.on_complete([&status](std::string /* body */, unsigned http_status){
+        status = http_status;
+    });
+
+    g.perform_sync();
+
+    REQUIRE(status == 200);
+}
+
+TEST_CASE("Http basic authentication", "[Http][NotWorking]") {
+    Slic3r::Http g = Slic3r::Http::get("https://httpbingo.org/basic-auth/guest/guest");
+
+    g.auth_basic("guest", "guest");
+
+    unsigned status = 0;
+    g.on_error([&status](std::string, std::string, unsigned http_status) {
+        status = http_status;
+    });
+
+    g.on_complete([&status](std::string /* body */, unsigned http_status){
+        status = http_status;
+    });
+
+    g.perform_sync();
+
+    REQUIRE(status == 200);
+}
+

tests/slic3rutils/test_action_source.cpp

@@ -73,6 +73,34 @@ TEST_CASE("ActionRegistry takes exclusive ownership of published actions", "[Act
     STATIC_CHECK(std::is_same_v<decltype(&ActionRegistry::upsert), ExpectedUpsert>);
 }
 
+// A dynamic "Go to Plate N" action is keyed by plate index (not the display title), so renaming
+// a plate never re-keys it - the same contract as a setting action.
+TEST_CASE("Go-to-plate actions are keyed by index, not title", "[ActionSource][SpeedDial]")
+{
+    CHECK(AppAction::compose_id("orca_plate_goto", "0", "orca") == "orca_plate_goto:0:orca");
+    CHECK(AppAction::compose_id("orca_plate_goto", "2", "orca") == "orca_plate_goto:2:orca");
+}
+
+// A dynamic "Open recent project" action is keyed by file path (not the display name), so renaming
+// a project or reordering the recents list never re-keys it - the same contract as a setting action.
+TEST_CASE("Recent-project actions are keyed by path, not title", "[ActionSource][SpeedDial]")
+{
+    CHECK(AppAction::compose_id("orca_recent_project", "/a/b/project.3mf", "orca") ==
+          "orca_recent_project:/a/b/project.3mf:orca");
+    CHECK(AppAction::compose_id("orca_recent_project", "C:/Data/cube.3mf", "orca") ==
+          "orca_recent_project:C:/Data/cube.3mf:orca");
+}
+
+// A built-in command is keyed by its stable catalog key (not the localized display title), so a
+// rename or a UI-language switch never re-keys the action and its persisted favourite/stats survive.
+TEST_CASE("Command actions are keyed by catalog key, not display title", "[ActionSource][SpeedDial]")
+{
+    CHECK(AppAction::compose_id("orca_command", "save_project", "orca") == "orca_command:save_project:orca");
+    // The second field is the stable key, so distinct commands never collide.
+    CHECK(AppAction::compose_id("orca_command", "save_project", "orca") !=
+          AppAction::compose_id("orca_command", "load_project", "orca"));
+}
+
 // The real catalog -> action mapping keys by the stable catalog key and copies presentation from the
 // catalog, so a rename or a UI-language switch never re-keys the action. The catalog's English title
 // and group become the action's English search aliases; no translation catalog is loaded in the tests,

tests/slic3rutils/test_moonraker_printer_agent.cpp

@@ -53,7 +53,7 @@ public:
     mutable unsigned fetch_count = 0;
 
 protected:
-    bool fetch_device_info(const std::string&, const std::string&, MoonrakerDeviceInfo& info, std::string&) const override
+    bool fetch_device_info(const ConnectionSettings&, MoonrakerDeviceInfo& info, std::string&) const override
     {
         ++fetch_count;
         info.dev_name = "Test printer";
@@ -65,21 +65,32 @@ class StreamAgent : public MoonrakerPrinterAgent
 {
 public:
     using MoonrakerPrinterAgent::MoonrakerPrinterAgent;
-    using MoonrakerPrinterAgent::start_status_stream;
-    using MoonrakerPrinterAgent::stop_status_stream;
     using MoonrakerPrinterAgent::ws_timings;
 
+    // Starts the stream the way a connection does, from a snapshot of the connection settings.
+    void start_stream(const std::string& base_url, bool use_ssl = false)
+    {
+        const std::string dev_id = "printer";
+        ConnectionSettings connection;
+        connection.dev_id   = dev_id;
+        connection.base_url = base_url;
+        connection.use_ssl  = use_ssl;
+        start_status_stream(dev_id, std::move(connection));
+    }
+
+    void stop_stream() { stop_status_stream(); }
+
 protected:
-    bool init_device_info(
+    bool init_device_info(const PrinterConnectionParams& params) override
-        const std::string& dev_id, const std::string& dev_ip, const std::string&, const std::string&, bool, const std::string& port) override
     {
         device_info          = MoonrakerDeviceInfo{};
-        device_info.dev_id   = dev_id;
+        device_info.dev_id   = params.dev_id;
-        device_info.base_url = "http://" + dev_ip + ":" + port;
+        device_info.dev_ip   = params.host;
+        device_info.base_url = std::string(params.use_ssl ? "https://" : "http://") + params.host + ":" + params.port;
         return true;
     }
 
-    bool fetch_device_info(const std::string&, const std::string&, MoonrakerDeviceInfo& info, std::string&) const override
+    bool fetch_device_info(const ConnectionSettings&, MoonrakerDeviceInfo& info, std::string&) const override
     {
         info.dev_name = "Test printer";
         return true;
@@ -97,6 +108,7 @@ enum class Behavior {
     IgnoresClose,              // Reports Klippy disconnected, then never answers the close
     StallsObjectList,          // Never answers the stream's object list request
     StallsStatusQuery,         // Never answers HTTP requests until released, then hangs up on them
+    RejectsTls,                // Records the first byte of the stream, which a TLS client sends as a handshake
 };
 
 class FakePrinter
@@ -150,6 +162,19 @@ public:
         return m_close_frames;
     }
 
+    // First byte the stream sent, or -1 until it has sent one.
+    bool wait_for_first_byte()
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, 10s, [&] { return m_first_byte >= 0; });
+    }
+
+    int first_byte()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_first_byte;
+    }
+
     // Hangs up every connection that is waiting.
     void release()
     {
@@ -182,6 +207,20 @@ private:
             return;
         }
 
+        if (m_behavior == Behavior::RejectsTls) {
+            char              first = 0;
+            beast::error_code ec;
+            socket.read_some(net::buffer(&first, 1), ec);
+            if (!ec) {
+                std::lock_guard<std::mutex> lock(m_mutex);
+                m_first_byte = static_cast<unsigned char>(first);
+                m_changed.notify_all();
+            }
+            mark_ready();
+            wait_for_release();
+            return;
+        }
+
         beast::flat_buffer buffer;
         http::request<http::string_body> request;
         beast::error_code ec;
@@ -335,6 +374,7 @@ private:
     int m_http_requests = 0;
     int m_http_hung_up  = 0;
     int m_close_frames  = 0;
+    int m_first_byte    = -1;
     bool m_released     = false;
 };
 
@@ -377,12 +417,15 @@ struct StreamFixture
     // Runs before the members are destroyed, so the agent's destructor never joins a stream the printer still holds open.
     ~StreamFixture() { printer.release(); }
 
-    void start() { agent.start_status_stream("printer", printer.base_url(), ""); }
+    void start() { agent.start_stream(printer.base_url()); }
+
+    // Runs the stream as a wss client; the printer must be served on the same port.
+    void start_secure() { agent.start_stream("https://" + printer.host() + ":" + printer.port(), true); }
 
     // Stops the stream, giving it `limit` to return before the printer hangs up on it.
     bool stops_within(std::chrono::milliseconds limit)
     {
-        auto stopped       = std::async(std::launch::async, [this] { agent.stop_status_stream(); });
+        auto stopped       = std::async(std::launch::async, [this] { agent.stop_stream(); });
         const bool in_time = stopped.wait_for(limit) == std::future_status::ready;
         printer.release();
         stopped.wait();
@@ -438,6 +481,16 @@ TEST_CASE("Stopping the status stream gives a silent printer no more than its ti
     CHECK(f.stops_within(limit));
 }
 
+TEST_CASE("A secure status stream opens with a TLS handshake", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::RejectsTls);
+    f.start_secure();
+    REQUIRE(f.printer.wait_for_first_byte());
+    // 0x16 is a TLS handshake record; a plaintext client would send "GET".
+    CHECK(f.printer.first_byte() == 0x16);
+    CHECK(f.stops_within(3s));
+}
+
 TEST_CASE("Stopping the status stream sends the printer a close frame", "[MoonrakerPrinterAgent][StatusStream]")
 {
     // A stop while the stream reads, and one while it waits on the object list request.
@@ -514,7 +567,7 @@ TEST_CASE("A callback on the stream thread can stop the status stream", "[Moonra
     StreamFixture f(Behavior::AnswersPings);
     f.agent.set_on_local_message_fn([&](std::string, std::string) {
         std::call_once(stopped_once, [&] {
-            f.agent.stop_status_stream();
+            f.agent.stop_stream();
             stopped.set_value();
         });
     });
@@ -572,9 +625,12 @@ TEST_CASE("A disconnect during the connection queries keeps the status stream fr
     f.agent.connect_printer(params);
     REQUIRE(f.printer.wait_for_http_requests(1));
 
-    f.agent.disconnect_printer();
+    // disconnect_printer joins the worker running the stalled query, so it is called aside and the
+    // printer is released to let that query return.
+    auto disconnecting = std::async(std::launch::async, [&] { f.agent.disconnect_printer(); });
     f.printer.release();
     // The query has returned once the printer hangs up on it, and a stream would connect right after.
     REQUIRE(f.printer.wait_for_http_hang_ups(1));
     CHECK_FALSE(f.printer.wait_for_ready_connections(1, 500ms));
+    disconnecting.wait();
 }

tests/slic3rutils/test_plugin_config.cpp

@@ -138,6 +138,22 @@ TEST_CASE("PluginConfig serializes the documented on-disk schema", "[PluginConfi
     CHECK(entry.size() == 5);
 }
 
+TEST_CASE("PluginConfig keeps a capability's config after its plugin goes away", "[PluginConfig]")
+{
+    ScopedDataDir data_dir_guard("plugin-config-retention");
+
+    {
+        PluginConfig config;
+        REQUIRE(config.store_capability_config(capability_id(PluginCapabilityType::Script, "cap_a", "plugin_a"), json{{"token", "keep me"}}));
+    }
+
+    // config.json is deliberately not keyed to installed plugins: a record outlives its plugin and is
+    // still there on reinstall. Asserts no cleanup path silently drops it.
+    PluginConfig after_removal;
+    after_removal.load();
+    CHECK(after_removal.get_config(capability_id(PluginCapabilityType::Script, "cap_a", "plugin_a"))->config == json{{"token", "keep me"}});
+}
+
 TEST_CASE("PluginConfig treats a missing config file as an empty store", "[PluginConfig]")
 {
     ScopedDataDir data_dir_guard("plugin-config-missing");

tests/slic3rutils/test_plugin_lifecycle.cpp

@@ -615,22 +615,8 @@ TEST_CASE("Python module release removes package submodules and owned sys.path",
 
     // Ensure the next import executes the new submodule rather than reusing a stale package child.
     write_package("'new'");
-    {
+    boost::system::error_code ec;
-        // The rewrite can keep the old mtime and size, so drop the bytecode wherever the
+    fs::remove_all(package_root / "__pycache__", ec);
-        // interpreter caches it.
-        PythonGILState gil;
-        REQUIRE(gil);
-        PyObjectPtr util(PyImport_ImportModule("importlib.util"));
-        REQUIRE(util);
-        for (const char* file : {"__init__.py", "sub.py"}) {
-            PyObjectPtr source(PyUnicode_DecodeFSDefault((package_root / file).string().c_str()));
-            REQUIRE(source);
-            PyObjectPtr cached(PyObject_CallMethod(util.get(), "cache_from_source", "O", source.get()));
-            REQUIRE(cached);
-            boost::system::error_code ec;
-            fs::remove(fs::path(PyUnicode_AsUTF8(cached.get())), ec);
-        }
-    }
 
     paths.clear();
     modules.clear();

tests/slic3rutils/test_printer_agent.cpp

@@ -1,18 +1,30 @@
 #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/matchers/catch_matchers.hpp"
+#include "catch2/matchers/catch_matchers_floating_point.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; }
@@ -20,12 +32,390 @@ 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", "[MoonrakerPrinterAgent]")
+{
+    const auto response = nlohmann::json::parse(R"({
+        "result": {
+            "status": {
+                "configfile": {
+                    "settings": {
+                        "extruder": {
+                            "nozzle_diameter": 0.6
+                        }
+                    }
+                }
+            }
+        }
+    })");
+
+    CHECK_THAT(MoonrakerParserProbe::parse_nozzle_diameter(response), Catch::Matchers::WithinAbs(0.6f, 1e-4f));
+}
+
+TEST_CASE("Moonraker parses nozzle diameter from raw config and tolerates missing data", "[MoonrakerPrinterAgent]")
+{
+    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_THAT(MoonrakerParserProbe::parse_nozzle_diameter(raw_config_response), Catch::Matchers::WithinAbs(0.8f, 1e-4f));
+    CHECK_THAT(MoonrakerParserProbe::parse_nozzle_diameter(missing_response), Catch::Matchers::WithinAbs(0.0f, 1e-6f));
+}
+
+// why: an agent without a Bambu-dialect translation must refuse these commands before any network or wx path.
+TEST_CASE("default AMS commands report not supported", "[MoonrakerPrinterAgent]")
+{
+    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("Moonraker light name matching", "[MoonrakerPrinterAgent]")
+{
+    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",
+          "[MoonrakerPrinterAgent]")
+{
+    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",
+          "[MoonrakerPrinterAgent]")
+{
+    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", "[MoonrakerPrinterAgent]")
+{
+    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("Moonraker reports untranslated commands as not supported", "[MoonrakerPrinterAgent]")
+{
+    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.
+// Pull-mode overrides must be synchronous (the caller reads DevFilaSystem as soon as it
+// returns), but subscription overrides may be fire-and-forget: QidiPrinterAgent/Snapmaker
+// spawn a detached thread when asked for subscription updates. QidiPrinterAgent is `final`,
+// so this probes the subscription contract with a controllable double instead.
+TEST_CASE("a fire-and-forget subscription fetch is not waited on by the caller",
+          "[MoonrakerPrinterAgent]")
+{
+    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
+        {
+            // Only the subscription path is allowed to be fire-and-forget.
+            if (sync_mode != FilamentSyncMode::subscription)
+                return true;
+
+            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", FilamentSyncMode::subscription);
+
+    // 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",
+          "[MoonrakerPrinterAgent][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
 // or previously registered agent.
 // ===========================================================================
-TEST_CASE("unit: printer-agent registry register / lookup / duplicate-reject", "[registry][unit]")
+TEST_CASE("printer-agent registry register / lookup / duplicate-reject", "[PrinterAgent]")
 {
     // why: the registry is process-global state shared by the test binary, and
     // Catch2 may run cases in any order. Use an id that cannot collide with
@@ -69,7 +459,7 @@ TEST_CASE("unit: printer-agent registry register / lookup / duplicate-reject", "
 // fails to load the codecs needed for the filesystem encoding. The shared helper
 // points PyConfig.home at the python/ runtime staged next to the test executable.
 
-TEST_CASE("integration: orca.printer_agent binding surface", "[integration][Python]")
+TEST_CASE("orca.printer_agent binding surface", "[integration][Python]")
 {
     py::module_ orca = import_orca_module();
 
@@ -120,7 +510,7 @@ TEST_CASE("integration: orca.printer_agent binding surface", "[integration][Pyth
 // them in the lightweight embedded-interpreter test catches binding breakage
 // before the plugin-loader test needs to run.
 // ===========================================================================
-TEST_CASE("integration: orca plugin-registration API surface + discovery-context guards", "[integration][Python]")
+TEST_CASE("orca plugin-registration API surface + discovery-context guards", "[integration][Python]")
 {
     py::module_ orca = import_orca_module();
 

tests/slic3rutils/test_qidi_printer_agent.cpp

@@ -0,0 +1,134 @@
+#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");
+}