Merge branch 'main' into feat/block-install-state

2.4.0 to 2.4.2 wrote auto_drop on each build item, and 2.4.x objects
carry no auto_drop attribute in model_settings.config. The importer only
read the object attribute and treated a missing one as on, so floating
objects were dropped to the bed on load and the flag was rewritten as on
on the next save.

Record object ids with an item auto_drop="0" and use that as the fallback
when the object has no attribute. The attribute's presence is now tracked
so the fallback applies only when it is absent. Any item set to off turns
auto drop off for the object, since the flag is shared by all instances.

localization/i18n/OrcaSlicer.pot

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

src/libslic3r/Format/bbs_3mf.cpp

@@ -988,7 +988,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
 
             MetadataList metadata;
             VolumeMetadataList volumes;
-            bool auto_drop { true };
+            std::optional<bool> auto_drop;
         };
 
         struct CutObjectInfo
@@ -1208,6 +1208,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         //IdToGeometryMap m_orig_geometries; // backup & restore
         CurrentConfig m_curr_config;
         IdToMetadataMap m_objects_metadata;
+        std::set<int>   m_items_auto_drop_off; // object ids with a build item auto_drop="0" (2.4.x layout)
         IdToCutObjectInfoMap       m_cut_object_infos;
         IdToLayerHeightsProfileMap m_layer_heights_profiles;
         IdToLayerConfigRangesMap m_layer_config_ranges;
@@ -1463,6 +1464,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         m_objects.clear();
         m_instances.clear();
         m_objects_metadata.clear();
+        m_items_auto_drop_off.clear();
         m_curr_metadata_name.clear();
         m_curr_characters.clear();
 
@@ -1502,6 +1504,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         m_curr_config.object_id = -1;
         m_curr_config.volume_id = -1;
         m_objects_metadata.clear();
+        m_items_auto_drop_off.clear();
         m_layer_heights_profiles.clear();
         m_layer_config_ranges.clear();
         m_brim_ear_points.clear();
@@ -2257,11 +2260,14 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             ObjectMetadata::VolumeMetadataList volumes;
             ObjectMetadata::VolumeMetadataList* volumes_ptr = nullptr;
 
+            // 2.4.x stored auto_drop on build items, shared by all instances of an object; any "off" wins
+            const bool legacy_auto_drop = !m_items_auto_drop_off.count(object.first.second);
+
             IdToMetadataMap::iterator obj_metadata = m_objects_metadata.find(object.first.second);
             if (obj_metadata != m_objects_metadata.end()) {
                 // config data has been found, this model was saved using slic3r pe
 
-                model_object->auto_drop = obj_metadata->second.auto_drop;
+                model_object->auto_drop = obj_metadata->second.auto_drop.value_or(legacy_auto_drop);
 
                 // apply object's name and config data
                 for (const Metadata& metadata : obj_metadata->second.metadata) {
@@ -2279,6 +2285,7 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
             }
             else {
                 // config data not found, this model was not saved using slic3r pe
+                model_object->auto_drop = legacy_auto_drop;
 
                 // add the entire geometry as the single volume to generate
                 //volumes.emplace_back(0, (int)obj_geometry->second.triangles.size() - 1);
@@ -4121,6 +4128,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         std::string path = bbs_get_attribute_value_string(attributes, num_attributes, PPATH_ATTR);
         Transform3d transform = bbs_get_transform_from_3mf_specs_string(bbs_get_attribute_value_string(attributes, num_attributes, TRANSFORM_ATTR));
         int printable = bbs_get_attribute_value_bool(attributes, num_attributes, PRINTABLE_ATTR);
+        if (const char* auto_drop = bbs_get_attribute_value_charptr(attributes, num_attributes, AUTO_DROP_ATTR); auto_drop != nullptr && !::atoi(auto_drop))
+            m_items_auto_drop_off.insert(object_id);
         return !m_load_model || _create_object_instance(path, object_id, transform, printable, 1);
     }
 
@@ -4489,7 +4498,8 @@ void PlateData::parse_filament_info(GCodeProcessorResult *result)
         // int instances_count_id = bbs_get_attribute_value_int(attributes, num_attributes, INSTANCESCOUNT_ATTR);
 
         ObjectMetadata metadata;
-        metadata.auto_drop = bbs_get_attribute_value_bool(attributes, num_attributes, AUTO_DROP_ATTR);
+        if (bbs_get_attribute_value_charptr(attributes, num_attributes, AUTO_DROP_ATTR) != nullptr)
+            metadata.auto_drop = bbs_get_attribute_value_bool(attributes, num_attributes, AUTO_DROP_ATTR);
         m_objects_metadata.insert({ object_id, std::move(metadata) });
         m_curr_config.object_id = object_id;
         return true;

src/libslic3r/Preset.hpp

@@ -756,7 +756,14 @@ public:
     Preset&         get_edited_preset()         { return m_edited_preset; }
     const Preset&   get_edited_preset() const   { return m_edited_preset; }
 
-    const Preset& get_selected_preset_base() const { return *get_preset_base(m_presets[m_idx_selected]); }
+    // The root of the selected preset's inherits chain, or the selected preset itself when
+    // 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,7 +15,6 @@
 #include <string>
 #include "slic3r/GUI/wxExtensions.hpp"
 #include "libslic3r/AppConfig.hpp"
-#include "IPrinterAgent.hpp"
 
 #include "DeviceCore/DevManager.h"
 
@@ -171,16 +170,14 @@ void ConnectPrinterDialog::on_input_enter(wxCommandEvent& evt)
 void ConnectPrinterDialog::on_button_confirm(wxCommandEvent &event)
 {
     wxString code = m_textCtrl_code->GetTextCtrl()->GetValue();
-    // Validate only what the user typed; the no-key sentinel is applied afterwards (it contains
+    if (code.empty() && (!m_obj || m_obj->printer_agent_id != MOONRAKER_PRINTER_AGENT_ID))
-    // non-alphanumeric characters, so it must not go through this check).
+        code = "88888888";
     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)->name != printer_preset.name) continue;
+        if (preset_bundle->printers.get_preset_base(printer_preset) != &printer_preset) 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) {
+                    if (filament_preset_base == &filament_preset || filament_preset_base == nullptr) {
                         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,8 +2685,7 @@ 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();
-    // The stored access code may be the "no API key" sentinel; agents expect an empty credential.
+    std::string password = get_access_code();
-    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,11 +4354,6 @@ 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,7 +2,6 @@
 #include "I18N.hpp"
 
 #include "bambu_networking.hpp"
-#include "IPrinterAgent.hpp"
 #include "libslic3r/Utils.hpp"
 #include "GUI.hpp"
 #include "GUI_App.hpp"
@@ -1904,7 +1903,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 = NO_API_KEY_SENTINEL;
+        str_access_code = "88888888";
     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.
@@ -1951,7 +1950,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 = NO_API_KEY_SENTINEL;
+        str_access_code = "88888888";
 
     // 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()->SetTextLabel("");
+        m_printer_box->GetPrinterComboBox()->SetValue(_L("No available printers"));
     }
 
     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->SetTextLabel("");
+        m_comboBox_printer->SetValue(_L("No available printers"));
     }
 
     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())
+    if (!IsEnabled() || items.empty())
         return;
 
     if (!drop_down) {
@@ -398,7 +398,7 @@ void ComboBox::mouseDown(wxMouseEvent &event)
     SetFocus();
     if (drop_down) {
         drop.Hide();
-    } else if (drop.HasDismissLongTime()) {
+    } else if (!items.empty() && drop.HasDismissLongTime()) { // DropDown paints nothing for an empty list
         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 (drop.HasDismissLongTime()) {
+            } else if (!items.empty() && drop.HasDismissLongTime()) {
                 drop.autoPosition();
                 drop_down = true;
                 drop.Popup();

src/slic3r/Utils/BBLPrinterAgent.cpp

@@ -204,9 +204,8 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
         int dir = input_val > 0 ? 1 : -1;
         // i3-arch printers move the bed for Y/Z, so the on-screen direction is
         // reversed -- same negation the g-code fallback below applies.
-        if (!is_core_xy && (axis == "Y" || axis == "Z")) {
+        if (!is_core_xy && (axis == "Y" || axis == "Z"))
             dir = -dir;
-        }
 
         j["print"]["command"] = "xyz_ctrl";
         j["print"]["axis"] = axis;
@@ -216,9 +215,8 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
     }
 
     double value = input_val;
-    if (!is_core_xy && (axis == "Y" || axis == "Z")) {
+    if (!is_core_xy && (axis == "Y" || axis == "Z"))
-        value = -1.0 * input_val;
+        value = -input_val;
-    }
 
     std::string value_str = (boost::format("%.1f") % (value * unit)).str();
     std::string gcode;
@@ -239,11 +237,10 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
 int BBLPrinterAgent::publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode)
 {
     const int rtn = lan_mode ? send_message_to_printer(dev_id, j.dump(), 0, 0) : send_message(dev_id, j.dump(), 0, 0);
-    if (rtn == 0) {
+    if (rtn == 0)
         BOOST_LOG_TRIVIAL(info) << "publish_json: " << j.dump() << " code: " << rtn;
-    } else {
+    else
         BOOST_LOG_TRIVIAL(error) << "publish_json: " << j.dump() << " code: " << rtn;
-    }
     return rtn;
 }
 
@@ -589,21 +586,8 @@ int BBLPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateS
 
 int BBLPrinterAgent::start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
 {
-    // dispatch_start() moves out of `params`, so snapshot the diagnostic fields first;
+    return dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
-    // 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,7 +110,6 @@ public:
     static std::string from_orca_payload(std::string json_text);
 
 private:
-    // why: the lan/cloud DECISION stays machine-side; keep this mechanical branch in sync with publish_json.
     int publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode);
 };
 

src/slic3r/Utils/CrealityPrintAgent.cpp

@@ -288,27 +288,22 @@ bool CrealityPrintAgent::parse_cfs_response(const std::string&    response,
     return true;
 }
 
-bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    if (sync_mode != get_filament_sync_mode())
+    if (device_info.dev_ip.empty()) {
-        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), sync_mode);
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
     }
 
     // Build a CrealityPrint helper so we can use its model detection + WS helpers
     // (added in upstream PR #13291).
     DynamicPrintConfig cfg;
-    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + info.dev_ip));
+    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + device_info.dev_ip));
     cfg.set_key_value("print_host_webui",            new ConfigOptionString(""));
     cfg.set_key_value("printhost_cafile",            new ConfigOptionString(""));
     cfg.set_key_value("printhost_port",              new ConfigOptionString(""));
-    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(info.api_key));
+    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(device_info.api_key));
     cfg.set_key_value("printhost_ssl_ignore_revoke", new ConfigOptionBool(false));
 
     CrealityPrint host(&cfg);
@@ -318,7 +313,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), sync_mode);
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
     }
 
     BOOST_LOG_TRIVIAL(info)
@@ -333,7 +328,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), sync_mode);
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
     }
 
     if (box_count == 0) {
@@ -342,7 +337,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), sync_mode);
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
     }
 
     BOOST_LOG_TRIVIAL(info)
@@ -387,7 +382,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         }
     }
 
-    build_ams_payload(box_count, max_slots - 1, trays, sync_mode == FilamentSyncMode::pull);
+    build_ams_payload(box_count, max_slots - 1, trays);
     return true;
 }
 

src/slic3r/Utils/CrealityPrintAgent.hpp

@@ -37,13 +37,12 @@ public:
     };
 
     explicit CrealityPrintAgent(std::string log_dir);
-    ~CrealityPrintAgent() override { shutdown(); }
+    ~CrealityPrintAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
     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,17 +45,6 @@ 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.
  *
@@ -466,16 +455,9 @@ public:
     virtual CameraStreamMode get_camera_stream_mode() const { return CameraStreamMode::none; }
 
     /**
-     * Refresh filament info from the printer.
+     * Refresh filament info from the printer synchronously.
-     *
+     * Should only be called when get_filament_sync_mode() returns FilamentSyncMode::pull.
-     * When called with FilamentSyncMode::pull (which requires get_filament_sync_mode() to
+     * Populates the MachineObject's DevFilaSystem with fetched filament data.
-     * 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,8 +13,6 @@
 #include <set>
 #include <string>
 #include <thread>
-#include <condition_variable>
-#include <deque>
 
 #include <nlohmann/json.hpp>
 #include <vector>
@@ -23,56 +21,6 @@ namespace Slic3r { class ICloudServiceAgent; }
 
 namespace Slic3r {
 
-class Http;
-
-bool moonraker_is_light_name(const std::string& name);
-// Direction encoded by a light name: +1 turns on, -1 turns off, 0 is an ambiguous toggle.
-// e.g. LIGHT_ON -> +1, LIGHT_OFF -> -1, LIGHT -> 0.
-int moonraker_light_name_direction(const std::string& name);
-
-struct MoonrakerWebcamSelection
-{
-    std::string      url;
-    CameraStreamMode mode = CameraStreamMode::none;
-    std::string      name;
-    std::string      error;  // set when no selectable webcam was found
-};
-
-// Selects a webcam from a parsed /server/webcams/list response (the top-level JSON or its
-// "result" value). Returns true and fills url/mode/name on success; on failure returns
-// false and sets error.
-bool moonraker_parse_webcam_list(const nlohmann::json& response, const std::string& base_url,
-                                 MoonrakerWebcamSelection& out);
-
-class MoonrakerWebsocket
-{
-public:
-    enum class ReadResult
-    {
-        message,
-        timeout,
-        closed,
-        error,
-    };
-
-    MoonrakerWebsocket(bool secure, std::string api_key, std::string ca_file);
-    ~MoonrakerWebsocket();
-
-    void connect(const std::string& host, const std::string& port, std::chrono::seconds timeout);
-    void tls_handshake(const std::string& host);
-    void handshake(const std::string& host, const std::string& target);
-    void text(bool enabled);
-    void write(const std::string& body);
-    ReadResult read(std::string& payload, std::string& error_message);
-    void close();
-    void expires_after(std::chrono::seconds timeout);
-    void abort();
-
-private:
-    struct Impl;
-    std::unique_ptr<Impl> m_impl;
-};
-
 class MoonrakerPrinterAgent : public IPrinterAgent
 {
 public:
@@ -118,26 +66,12 @@ public:
     int set_on_local_connect_fn(OnLocalConnectedFn fn) override;
     int set_on_local_message_fn(OnMessageFn fn) override;
     int set_queue_on_main_fn(QueueOnMainFn fn) override;
-    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
+
     // Pull-mode agent (on-demand filament sync)
     FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::pull; }
-    CameraStreamMode get_camera_stream_mode() const override;
+    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) 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;
@@ -149,9 +83,7 @@ protected:
         std::string dev_name;
         std::string version;
         std::string klippy_state;
-        float       nozzle_diameter = 0.0f;
         bool        use_ssl = false;
-        std::string ca_file;
     } device_info;
 
     // Copied when the stream starts, so changes apply to the next start_status_stream()
@@ -175,47 +107,18 @@ protected:
         int         nozzle_temp = 0;     // Optional
     };
 
-    // Build ams JSON and call parser.
+    // Build ams JSON and call parser
-    // apply_inline: when true the MachineObject mutation runs on the calling thread, which
+    void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
-    // 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 PrinterConnectionParams& params);
+    virtual bool init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port);
-    virtual bool fetch_device_info(const ConnectionSettings& connection, MoonrakerDeviceInfo& info, std::string& error) const;
+    virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
-    ConnectionSettings get_connection_settings() const;
+    void start_status_stream(const std::string& dev_id, const std::string& base_url, const std::string& api_key);
-    // 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);
@@ -228,30 +131,13 @@ protected:
     // Map filament type to OrcaFilamentLibrary preset ID for AMS sync compatibility
     static std::string map_filament_type_to_generic_id(const std::string& filament_type);
 
-    // Send a G-code script via Moonraker (/printer/gcode/script)
-    bool send_gcode(const std::string& dev_id, const std::string& gcode) const;
-    bool send_gcode(const std::string& dev_id, const std::string& gcode,
-                    const ConnectionSettings& connection) const;
-    bool post_print_action(const std::string& action) const;
-    bool post_print_action(const std::string& action,
-                           const ConnectionSettings& connection) const;
-
-    bool send_ws_rpc(const std::string& method, const nlohmann::json& params);
-
-    virtual void on_status_loop_tick(const std::string& dev_id) {}
-
-    // Queue work that may use agent state. The command worker is joined during
-    // destruction, so queued commands cannot outlive the agent.
-    void enqueue_command(std::function<void()> fn);
-    mutable std::recursive_mutex connect_mutex;
-
 private:
     int handle_request(const std::string& dev_id, const std::string& json_str);
     int send_version_info(const std::string& dev_id);
     int send_access_code(const std::string& dev_id);
 
-    bool fetch_object_list(const ConnectionSettings& connection, std::set<std::string>& objects, std::string& error) const;
+    bool fetch_object_list(const std::string& base_url, const std::string& api_key, std::set<std::string>& objects, std::string& error) const;
-    bool query_printer_status(const ConnectionSettings& connection, nlohmann::json& status, std::string& error) const;
+    bool query_printer_status(const std::string& base_url, const std::string& api_key, nlohmann::json& status, std::string& error) const;
     bool send_gcode_sync(const std::string& dev_id, const std::string& gcode) const;
     void send_gcode_async(const std::string& dev_id, const std::string& gcode,
                           std::function<void(bool)> on_result = {}) const;
@@ -259,46 +145,38 @@ 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, ConnectionSettings connection, StatusStreamTimings timings);
+    void run_status_stream(std::string dev_id, std::string base_url, std::string api_key, StatusStreamTimings timings);
-    void handle_ws_message(std::string dev_id, std::string payload, ConnectionSettings connection);
+    void handle_ws_message(const std::string& dev_id, const std::string& payload);
     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 ConnectionSettings& connection,
+                      const std::string& base_url, const std::string& api_key,
                       OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
 
+    // JSON-RPC helper
+    bool send_jsonrpc_command(const std::string& base_url, const std::string& api_key,
+                              const nlohmann::json& request, std::string& response) const;
+
     // Connection thread management
     void perform_connection_async(const std::string& dev_id,
-                                   ConnectionSettings connection,
+                                   const std::string& base_url,
+                                   const std::string& api_key,
                                    uint64_t generation);
 
-    void refresh_webcam_info() const;
-    bool fetch_webcam_info(const ConnectionSettings& connection, uint64_t generation) const;
-
     // System-specific filament fetch methods
-    bool fetch_hh_filament_info(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_hh_filament_info(std::vector<AmsTrayData>& trays, int& max_lane_index);
-    bool fetch_moonraker_filament_data(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_moonraker_filament_data(std::vector<AmsTrayData>& trays, int& max_lane_index);
 
     // JSON helper methods
     static std::string safe_json_string(const nlohmann::json& obj, const char* key);
@@ -324,37 +202,16 @@ 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
-    // Guards ws_thread and ws_abort. ws_abort posts to the stream's io_context, cancelling the
+    std::function<void()> ws_abort; // Interrupts whatever the stream thread is waiting on, from any thread
-    // 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
@@ -365,13 +222,7 @@ 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,25 +2,18 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
-#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
-#include <atomic>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/log/trivial.hpp>
 #include <cctype>
-#include <cmath>
 #include "libslic3r/Preset.hpp"
-#include <cstddef>
-#include <exception>
 #include <map>
-#include <mutex>
 #include <sstream>
-#include <thread>
 #include <string>
 #include <utility>
 #include <vector>
@@ -41,40 +34,6 @@ bool has_visible_base_preset(const PresetCollection& filaments, const std::strin
     return false;
 }
 
-// RAII release of the in-flight fetch slot; movable so a failed thread start still releases it.
-struct InFlightGuard
-{
-    MoonrakerPrinterAgent* owner;
-    explicit InFlightGuard(MoonrakerPrinterAgent& o) noexcept : owner(&o) {}
-    InFlightGuard(InFlightGuard&& other) noexcept : owner(other.owner) { other.owner = nullptr; }
-    InFlightGuard(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(InFlightGuard&&) = delete;
-    ~InFlightGuard() { if (owner) owner->release_fetch_slot(); }
-};
-
-// nlohmann::json::value() returns the default only when the key is absent; a present but
-// null/wrong-typed value throws. Firmware JSON is untrusted, so read defensively.
-int read_int_or(const nlohmann::json& obj, const std::string& key, int fallback)
-{
-    auto it = obj.find(key);
-    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";
@@ -88,179 +47,51 @@ AgentInfo QidiPrinterAgent::get_agent_info_static()
     return AgentInfo{"qidi", "Qidi", QidiPrinterAgent_VERSION, "Qidi printer agent"};
 }
 
-FilamentSyncMode QidiPrinterAgent::get_filament_sync_mode() const
+bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
+    std::string error;
-        return FilamentSyncMode::subscription;
-    return FilamentSyncMode::pull;
-}
 
-bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+    // 1. Fetch device info and infer series_id
-{
+    std::string series_id;
-    if (sync_mode != get_filament_sync_mode())
-        return false;
-
-    // Snapshot what the fetch needs; a reconnect can rewrite device_info meanwhile.
-    ConnectionSettings connection = get_connection_settings();
-    std::string        model_id;
-    std::string        model_name;
     {
-        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
+        MoonrakerDeviceInfo info;
-        model_id   = device_info.model_id;
+        if (fetch_device_info(device_info.base_url, device_info.api_key, info, error)) {
-        model_name = device_info.model_name;
+            series_id = infer_series_id(info.model_id, info.dev_name);
-    }
-
-    // One implementation for both modes; only where it runs differs. pull is the documented
-    // 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 (series_id.empty()) {
-    if (sync_mode == FilamentSyncMode::pull) {
+        // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
-        return work(/*apply_inline=*/true);
+        series_id = infer_series_id(device_info.model_id, device_info.model_name);
     }
 
-    // Subscription: fire-and-forget. A `true` return means the refresh was scheduled (or is
+    // 2. Fetch filament dictionary
-    // already running), not that DevFilaSystem has been updated. Reserve under the same mutex
+    QidiFilamentDict dict;
-    // shutdown() uses, so the flag and the count can't race.
+    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;
-        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};
+    // 3. Fetch slot info and build AmsTrayData directly
-    std::thread([work = std::move(work), guard = std::move(guard)]() mutable {
+    std::vector<AmsTrayData> trays;
-        work(/*apply_inline=*/false);
+    int                      box_count = 0;
-    }).detach();
+    if (!fetch_slot_info(device_info.base_url, device_info.api_key, dict, series_id, trays, box_count, error)) {
+        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
+        return false;
+    }
+
+    // 4. Build the AMS payload
+    build_ams_payload(box_count, box_count * 4 - 1, trays);
     return true;
 }
 
-bool QidiPrinterAgent::apply_box_mapping(const PrintParams& params) const
+bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
-{
+                                       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(connection.base_url, "/printer/objects/query?save_variables=variables");
+    std::string url = join_url(base_url, "/printer/objects/query?save_variables=variables");
     for (int i = 0; i < 16; ++i) {
         url += "&box_stepper%20slot" + std::to_string(i) + "=runout_button";
     }
@@ -270,9 +101,8 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
     std::string http_error;
 
     auto http = Http::get(url);
-    configure_http(http, connection);
+    if (!api_key.empty()) {
-    if (!connection.api_key.empty()) {
+        http.header("X-Api-Key", api_key);
-        http.header("X-Api-Key", connection.api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)
@@ -297,12 +127,22 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         return false;
     }
 
-    nlohmann::json status;
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-    nlohmann::json variables;
+    if (json.is_discarded()) {
-    if (!parse_slot_response(response_body, status, variables, error))
+        error = "Invalid JSON response";
         return false;
+    }
 
-    box_count = read_int_or(variables, "box_count", 1);
+    if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("save_variables") ||
+        !json["result"]["status"]["save_variables"].contains("variables")) {
+        error = "Unexpected JSON structure";
+        return false;
+    }
+
+    auto& variables = json["result"]["status"]["save_variables"]["variables"];
+    auto& status    = json["result"]["status"];
+
+    box_count = variables.value("box_count", 1);
     if (box_count < 0) {
         box_count = 0;
     }
@@ -325,9 +165,9 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         tray.slot_index = i;
 
         // Read slot variables
-        const int color_index     = read_int_or(variables, "color_slot" + std::to_string(i), 1);
+        const int color_index     = variables.value("color_slot" + std::to_string(i), 1);
-        const int filament_type   = read_int_or(variables, "filament_slot" + std::to_string(i), 1);
+        const int filament_type   = variables.value("filament_slot" + std::to_string(i), 1);
-        const int vendor_type     = read_int_or(variables, "vendor_slot" + std::to_string(i), 0);
+        const int vendor_type     = variables.value("vendor_slot" + std::to_string(i), 0);
 
         // Check filament presence via runout sensor
         std::string box_stepper_key = "box_stepper slot" + std::to_string(i);
@@ -335,7 +175,7 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         if (status.contains(box_stepper_key)) {
             auto& box_stepper = status[box_stepper_key];
             if (box_stepper.contains("runout_button") && !box_stepper["runout_button"].is_null()) {
-                const int runout_button = read_int_or(box_stepper, "runout_button", 0);
+                int runout_button = box_stepper["runout_button"].template get<int>();
                 tray.has_filament = (runout_button == 0);
             }
         }
@@ -349,9 +189,16 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
             }
             tray.tray_type = normalize_filament_type(filament_name);
 
-            // Qidi-specific setting id derived from device data only; the preset-dependent
+            // Try Qidi-specific setting ID first; fall back to visible preset by type
-            // fallback runs on the main thread in the resolve hook passed to build_ams_payload.
+            std::string setting_id = build_setting_id(filament_type, vendor_type, tray.tray_type);
-            tray.tray_info_idx = build_setting_id(filament_type, vendor_type, tray.tray_type);
+            auto* bundle = GUI::wxGetApp().preset_bundle;
+            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);
@@ -368,45 +215,20 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
     return true;
 }
 
-bool QidiPrinterAgent::parse_slot_response(const std::string& response_body,
+bool QidiPrinterAgent::fetch_filament_dict(const std::string& base_url,
-                                           nlohmann::json&    status,
+                                           const std::string& api_key,
-                                           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(connection.base_url, "/server/files/config/officiall_filas_list.cfg");
+    std::string url = join_url(base_url, "/server/files/config/officiall_filas_list.cfg");
 
     std::string response_body;
     bool        success = false;
     std::string http_error;
 
     auto http = Http::get(url);
-    configure_http(http, connection);
+    if (!api_key.empty()) {
-    if (!connection.api_key.empty()) {
+        http.header("X-Api-Key", api_key);
-        http.header("X-Api-Key", connection.api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)

src/slic3r/Utils/QidiPrinterAgent.hpp

@@ -3,8 +3,6 @@
 
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
-#include "bambu_networking.hpp"
-#include "nlohmann/json_fwd.hpp"
 
 #include <map>
 #include <string>
@@ -16,7 +14,7 @@ class QidiPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit QidiPrinterAgent(std::string log_dir);
-    ~QidiPrinterAgent() override { shutdown(); }
+    ~QidiPrinterAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
@@ -24,22 +22,7 @@ public:
     // Override filament sync (Qidi-specific implementation)
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
-    static bool parse_slot_response(const std::string& response_body,
-                                    nlohmann::json&    status,
-                                    nlohmann::json&    variables,
-                                    std::string&       error);
-
-    // Print operations — emit QiDi multi-color box config, then delegate to base.
-    // 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;
@@ -47,13 +30,14 @@ private:
     };
 
     // Qidi-specific methods
-    bool fetch_slot_info(const ConnectionSettings& connection,
+    bool fetch_slot_info(const std::string&        base_url,
+                         const std::string&        api_key,
                          const QidiFilamentDict&   dict,
                          const std::string&        series_id,
                          std::vector<AmsTrayData>& trays,
                          int&                      box_count,
                          std::string&              error);
-    bool fetch_filament_dict(const ConnectionSettings& connection, QidiFilamentDict& dict, std::string& error) const;
+    bool fetch_filament_dict(const std::string& base_url, const std::string& api_key, QidiFilamentDict& dict, std::string& error) const;
     std::string normalize_filament_type(const std::string& filament_type);
     std::string infer_series_id(const std::string& model_id, const std::string& dev_name);
     std::string normalize_model_key(std::string value);

src/slic3r/Utils/SnapmakerPrinterAgent.cpp

@@ -2,20 +2,11 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
-#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
-#include <atomic>
 #include <boost/log/trivial.hpp>
-#include <chrono>
-#include <cmath>
-#include <cstdint>
-#include <exception>
-#include <mutex>
-#include <sstream>
-#include <thread>
 #include <vector>
 #include <string>
 #include "libslic3r/Preset.hpp"
@@ -27,91 +18,6 @@ namespace Slic3r {
 namespace {
 
 constexpr const char* SNAPMAKER_AGENT_VERSION = "0.0.1";
-constexpr int64_t     CAMERA_REFRESH_INTERVAL_MS = 300'000;
-
-int64_t now_ms()
-{
-    return std::chrono::duration_cast<std::chrono::milliseconds>(
-        std::chrono::steady_clock::now().time_since_epoch()).count();
-}
-
-// RAII release of the in-flight fetch slot; movable so a failed thread start still releases it.
-struct InFlightGuard
-{
-    MoonrakerPrinterAgent* owner;
-    explicit InFlightGuard(MoonrakerPrinterAgent& o) noexcept : owner(&o) {}
-    InFlightGuard(InFlightGuard&& other) noexcept : owner(other.owner) { other.owner = nullptr; }
-    InFlightGuard(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(const InFlightGuard&) = delete;
-    InFlightGuard& operator=(InFlightGuard&&) = delete;
-    ~InFlightGuard() { if (owner) owner->release_fetch_slot(); }
-};
-
-// nlohmann::json::value() returns the default only when the key is absent; a present but
-// null/wrong-typed value throws. Firmware JSON is untrusted, so read defensively.
-int read_int_or(const nlohmann::json& obj, const char* key, int fallback)
-{
-    auto it = obj.find(key);
-    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>
@@ -134,16 +40,14 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
             filaments.get_preset_base(p) == &p && p.config.opt_string("filament_vendor", 0u) == vendor_name &&
             p.config.opt_string("filament_type", 0u) == filament_type) {
             // The printer returns RGBA in the format RRGGBBAA, but profiles store color as #RRGGBB,
-            // so we must remove # and ignore alpha channel for distance calculation. Firmware
+            // so we must remove # and ignore alpha channel for distance calculation
-            // colours are untrusted; parse_hex_color tolerates empty/non-hex instead of throwing.
+            unsigned int target_color_value = std::stoul(color_rgba.substr(0, color_rgba.length() - 2), nullptr, 16);
-            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 = 0;
+            unsigned int p_color_value;
             if (!p_color.empty()) {
-                size_t hash_pos = p_color.find("#");
+                size_t       hash_pos = p_color.find("#");
-                p_color_value   = parse_hex_color(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0));
+                p_color_value         = std::stoul(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0), nullptr, 16);
             } else {
                 // Default to black if no color specified in profile. Assume other profiles might be a closer color match.
                 // Could be a problem if the target color is also black and there exist a specific profile for that type, vendor and color
@@ -170,31 +74,6 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
 
 SnapmakerPrinterAgent::SnapmakerPrinterAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
 
-void SnapmakerPrinterAgent::start_camera_monitor()
-{
-    enqueue_command([this] {
-        send_ws_rpc("camera.start_monitor",
-                    {{"domain", "lan"}, {"interval", 0}, {"expect_pw", false}});
-    });
-    m_camera_last_fire_ms.store(now_ms());
-}
-
-void SnapmakerPrinterAgent::on_status_loop_tick(const std::string& dev_id)
-{
-    (void) dev_id;
-    const int64_t last = m_camera_last_fire_ms.load();
-    if (last == 0 || now_ms() - last >= CAMERA_REFRESH_INTERVAL_MS) {
-        start_camera_monitor();
-    }
-}
-
-int SnapmakerPrinterAgent::command_start_camera(std::string dev_id)
-{
-    (void) dev_id;
-    start_camera_monitor();
-    return BAMBU_NETWORK_SUCCESS;
-}
-
 AgentInfo SnapmakerPrinterAgent::get_agent_info_static()
 {
     return AgentInfo{"snapmaker", "Snapmaker", SNAPMAKER_AGENT_VERSION, "Snapmaker printer agent"};
@@ -230,192 +109,127 @@ std::string SnapmakerPrinterAgent::combine_filament_type(const std::string& type
     return base;
 }
 
-bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    (void) dev_id;
+    std::string url = join_url(device_info.base_url, "/printer/objects/query?print_task_config&filament_detect");
-    if (sync_mode != get_filament_sync_mode())
+
+    std::string response_body;
+    bool        success = false;
+    std::string http_error;
+
+    auto http = Http::get(url);
+    if (!device_info.api_key.empty()) {
+        http.header("X-Api-Key", device_info.api_key);
+    }
+    http.timeout_connect(5)
+        .timeout_max(10)
+        .on_complete([&](std::string body, unsigned status) {
+            if (status == 200) {
+                response_body = body;
+                success       = true;
+            } else {
+                http_error = "HTTP error: " + std::to_string(status);
+            }
+        })
+        .on_error([&](std::string body, std::string err, unsigned status) {
+            http_error = err;
+            if (status > 0) {
+                http_error += " (HTTP " + std::to_string(status) + ")";
+            }
+        })
+        .perform_sync();
+
+    if (!success) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
         return false;
+    }
 
-    // Snapshot everything the fetch needs (URL, api key, TLS/CA): a reconnect can rewrite
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-    // device_info meanwhile.
+    if (json.is_discarded()) {
-    const ConnectionSettings connection = get_connection_settings();
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
+        return false;
+    }
 
-    // One implementation for both modes; only where it runs differs. pull is the documented
+    // Navigate to result.status.print_task_config
-    // blocking contract (the GUI thread reads DevFilaSystem right after the call), so it runs
+    if (!json.contains("result") || !json["result"].contains("status") ||
-    // on the caller with the payload applied inline. subscription runs on a background thread
+        !json["result"]["status"].contains("print_task_config")) {
-    // so the status loop is not stalled, and the payload is marshalled back to the main thread.
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
-    auto work = [this, connection](bool apply_inline) -> bool {
+        return false;
-        try {
+    }
-            const std::string url = join_url(connection.base_url, "/printer/objects/query?print_task_config&filament_detect");
 
-            std::string response_body;
+    auto& ptc = json["result"]["status"]["print_task_config"];
-            bool success = false;
-            std::string http_error;
 
-            auto http = Http::get(url);
+    // Read parallel arrays from print_task_config
-            configure_http(http, connection);
+    auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
-            if (!connection.api_key.empty()) {
+    auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
-                http.header("X-Api-Key", connection.api_key);
+    auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
-            }
+    auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
-            http.timeout_connect(5)
+    auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
-                .timeout_max(10)
-                .on_complete([&](std::string body, unsigned status) {
-                    if (status == 200) {
-                        response_body = body;
-                        success       = true;
-                    } else {
-                        http_error = "HTTP error: " + std::to_string(status);
-                    }
-                })
-                .on_error([&](std::string body, std::string err, unsigned status) {
-                    http_error = err;
-                    if (status > 0) {
-                        http_error += " (HTTP " + std::to_string(status) + ")";
-                    }
-                })
-                .perform_sync();
 
-            if (!success) {
+    const int slot_count = static_cast<int>(filament_exist.size());
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
+    if (slot_count == 0) {
-                return false;
+        BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
-            }
+        return false;
+    }
 
-            auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    // Read NFC filament_detect data for temperature info (optional)
-            if (json.is_discarded()) {
+    nlohmann::json nfc_info;
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
+    if (json["result"]["status"].contains("filament_detect") &&
-                return false;
+        json["result"]["status"]["filament_detect"].contains("info")) {
-            }
+        nfc_info = json["result"]["status"]["filament_detect"]["info"];
+    }
 
-            // Navigate to result.status.print_task_config
+    static const std::string empty_str;
-            if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("print_task_config")) {
+    static const std::string default_color = "FFFFFFFF";
-                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
-                return false;
-            }
 
-            auto& ptc = json["result"]["status"]["print_task_config"];
+    std::vector<AmsTrayData> trays;
+    trays.reserve(slot_count);
 
-            // Read parallel arrays from print_task_config
+    for (int i = 0; i < slot_count; ++i) {
-            auto filament_exist    = read_bool_array_or(ptc, "filament_exist");
+        AmsTrayData tray;
-            auto filament_type     = read_string_array_or(ptc, "filament_type");
+        tray.slot_index   = i;
-            auto filament_sub_type = read_string_array_or(ptc, "filament_sub_type");
+        tray.has_filament = filament_exist[i];
-            auto filament_color    = read_string_array_or(ptc, "filament_color_rgba");
-            auto filament_vendor   = read_string_array_or(ptc, "filament_vendor");
 
-            const int slot_count = static_cast<int>(filament_exist.size());
+        if (tray.has_filament) {
-            if (slot_count == 0) {
+            tray.tray_type     = combine_filament_type(safe_at(filament_type, i, empty_str),
-                BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
+                                                       safe_at(filament_sub_type, i, empty_str));
-                return false;
+            tray.tray_color    = safe_at(filament_color, i, default_color);
-            }
 
-            // Read NFC filament_detect data for temperature info (optional)
+            auto* bundle = GUI::wxGetApp().preset_bundle;
-            nlohmann::json nfc_info;
+            // Try to find a matching preset for this filament based on vendor, type and color.
-            if (json["result"]["status"].contains("filament_detect") && json["result"]["status"]["filament_detect"].contains("info")) {
+            // If not found, default to traditional search by type only or generic type mapping.
-                nfc_info = json["result"]["status"]["filament_detect"]["info"];
+            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);
 
-            static const std::string empty_str;
+                if (!filament_id.empty()) {
-            static const std::string default_color = "FFFFFFFF";
+                    tray.tray_info_idx = filament_id;
-
+                    BOOST_LOG_TRIVIAL(warning) << "Filament sync: Found manufacturer-specific profile for slot " << i << ": "
-            // Per-tray vendor names, kept so the preset lookup can run on the main thread.
+                                               << filament_id;
-            std::vector<std::string> vendors(slot_count);
+                } else {
-
+                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
-            std::vector<AmsTrayData> trays;
-            trays.reserve(slot_count);
-
-            for (int i = 0; i < slot_count; ++i) {
-                AmsTrayData tray;
-                tray.slot_index   = i;
-                tray.has_filament = filament_exist[i];
-
-                if (tray.has_filament) {
-                    tray.tray_type  = combine_filament_type(safe_at(filament_type, i, empty_str), safe_at(filament_sub_type, i, empty_str));
-                    tray.tray_color = safe_at(filament_color, i, default_color);
-                    vendors[i]      = safe_at(filament_vendor, i, empty_str);
-
-                    // Generic id derived from device data only; the preset-dependent lookup runs
-                    // on the main thread in the resolve hook passed to build_ams_payload.
-                    tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
-
-                    // Extract NFC temperature data if available
-                    if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
-                        auto&       nfc_slot = nfc_info[i];
-                        std::string vendor   = "NONE";
-                        if (auto vendor_it = nfc_slot.find("VENDOR"); vendor_it != nfc_slot.end() && vendor_it->is_string()) {
-                            vendor = vendor_it->get<std::string>();
-                        }
-                        if (vendor != "NONE" && !vendor.empty()) {
-                            tray.bed_temp    = read_int_or(nfc_slot, "BED_TEMP", 0);
-                            tray.nozzle_temp = read_int_or(nfc_slot, "FIRST_LAYER_TEMP", 0);
-                        }
-                    }
                 }
-
+            } else {
-                trays.emplace_back(std::move(tray));
+                tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
             }
 
-            // Resolve against GUI-owned presets on the main thread (inside build_ams_payload).
+            // Extract NFC temperature data if available
-            auto resolve_ids = [vendors](std::vector<AmsTrayData>& resolved_trays) {
+            if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
-                auto* bundle = GUI::wxGetApp().preset_bundle;
+                auto& nfc_slot = nfc_info[i];
-                if (!bundle) {
+                std::string vendor = nfc_slot.value("VENDOR", "NONE");
-                    return; // keep the generic ids computed from device data
+                if (vendor != "NONE" && !vendor.empty()) {
+                    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;
         }
-    };
 
-    if (sync_mode == FilamentSyncMode::pull) {
+        trays.emplace_back(std::move(tray));
-        return work(/*apply_inline=*/true);
     }
 
-    // Subscription: fire-and-forget. A `true` return means the refresh was scheduled (or is
+    build_ams_payload(1, slot_count - 1, trays);
-    // 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,8 +3,6 @@
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 
-#include <atomic>
-#include <cstdint>
 #include <string>
 
 namespace Slic3r {
@@ -13,25 +11,16 @@ class SnapmakerPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit SnapmakerPrinterAgent(std::string log_dir);
-    ~SnapmakerPrinterAgent() override { shutdown(); }
+    ~SnapmakerPrinterAgent() override = default;
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
-    FilamentSyncMode get_filament_sync_mode() const override;
-    int command_start_camera(std::string dev_id) override;
-    CameraStreamMode get_camera_stream_mode() const override { return CameraStreamMode::http_snapshot; }
-    std::string get_camera_url() const override;
 
 private:
     // Combine filament_type + filament_sub_type into a unified type string
     static std::string combine_filament_type(const std::string& type, const std::string& sub_type);
-
-    void start_camera_monitor();
-    void on_status_loop_tick(const std::string& dev_id) override;
-
-    std::atomic<int64_t> m_camera_last_fire_ms{0};
 };
 
 } // namespace Slic3r

src/slic3r/plugin/PluginAuditManager.cpp

@@ -296,16 +296,18 @@ void PluginAuditManager::add_denied_filename(const std::string& filename)
 std::vector<std::string> PluginAuditManager::default_denied_filenames()
 {
     // AppConfig::config_path() picks .conf vs .ini on the USE_JSON_CONFIG ifdef and the app key
-    // on its mode, and is a non-static member we cannot call without an instance.  Denying all
+    // on its mode, and is a non-static member we cannot call without an instance. Denying all
     // four names is cheaper and more robust than replicating that; the two unused names cost one
-    // string comparison each.  Single-sourced here so install_hook() and the tests seed from the
+    // string comparison each. Keep the plugin install-state sidecar here too: it controls which
-    // same list and cannot drift apart.
+    // packages load on startup and must remain host-managed. Single-sourced so install_hook() and
+    // the tests seed from the same list and cannot drift apart.
     return {
         SLIC3R_APP_KEY ".conf",
         GCODEVIEWER_APP_KEY ".conf",
         SLIC3R_APP_KEY ".ini",
         GCODEVIEWER_APP_KEY ".ini",
         secret_constants::USER_SECRET_FILENAME,
+        ".install_state.json",
     };
 }
 
@@ -1076,8 +1078,9 @@ void PluginAuditManager::install_hook()
     // "cert" denied-path keyword seeded below.
     add_global_allowed_root(resources_dir(), /*allow_write=*/false);
 
-    // The user's app config and cloud credentials live directly inside data_dir(), so the
+    // The user's app config and cloud credentials live directly inside data_dir(), and plugin
-    // root just granted would otherwise expose them to any plugin.  Deny them by name.
+    // install state lives beneath it, so the root just granted would otherwise expose them to
+    // plugins. Deny them by name.
     //
     // Seeded here rather than by each secret's owner because install_hook() runs during lazy
     // interpreter init and therefore provably precedes any plugin bytecode, whereas

src/slic3r/plugin/PythonInterpreter.cpp

@@ -584,6 +584,19 @@ 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/libslic3r/test_3mf.cpp

@@ -505,6 +505,28 @@ TEST_CASE("A project whose components reference themselves fails to load", "[3mf
     REQUIRE_FALSE(loaded);
 }
 
+TEST_CASE("A project in the 2.4.x layout keeps auto drop off from its build item", "[3mf][Regression]")
+{
+    // 2.4.x wrote auto_drop on the build item and left it off the object, so the object is re-laid out here.
+    ScopedTemporaryFile temp(".3mf");
+    {
+        Model        model;
+        ModelObject* object = model.add_object();
+        object->add_volume(make_cube(10., 10., 10.));
+        object->add_instance();
+        object->auto_drop = false;
+        store_project(model, temp.string(), SaveStrategy::Zip64 | SaveStrategy::Silence);
+    }
+    REQUIRE(replace_in_3mf_entry(temp.string(), "model_settings.config", " auto_drop=\"0\"", ""));
+    REQUIRE(replace_in_3mf_entry(temp.string(), "3dmodel.model", "printable=\"1\"/>", "printable=\"1\" auto_drop=\"0\"/>"));
+
+    ScopedTemporaryDir backup_dir("orca_auto_drop_dst");
+    Model              model;
+    REQUIRE(load_project(temp.string(), model, backup_dir));
+    REQUIRE(model.objects.size() == 1);
+    CHECK_FALSE(model.objects.front()->auto_drop);
+}
+
 TEST_CASE("An object loads up to the component reference budget and fails past it", "[3mf][Regression]")
 {
     // The importer queues at most 100000 component references per object. Every reference besides the

tests/libslic3r/test_preset_bundle_loading.cpp

@@ -1219,6 +1219,24 @@ 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/slic3rutils/CMakeLists.txt

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

tests/slic3rutils/test_moonraker_printer_agent.cpp

@@ -53,7 +53,7 @@ public:
     mutable unsigned fetch_count = 0;
 
 protected:
-    bool fetch_device_info(const ConnectionSettings&, MoonrakerDeviceInfo& info, std::string&) const override
+    bool fetch_device_info(const std::string&, const std::string&, MoonrakerDeviceInfo& info, std::string&) const override
     {
         ++fetch_count;
         info.dev_name = "Test printer";
@@ -65,32 +65,21 @@ 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(const PrinterConnectionParams& params) override
+    bool init_device_info(
+        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   = params.dev_id;
+        device_info.dev_id   = dev_id;
-        device_info.dev_ip   = params.host;
+        device_info.base_url = "http://" + dev_ip + ":" + port;
-        device_info.base_url = std::string(params.use_ssl ? "https://" : "http://") + params.host + ":" + params.port;
         return true;
     }
 
-    bool fetch_device_info(const ConnectionSettings&, MoonrakerDeviceInfo& info, std::string&) const override
+    bool fetch_device_info(const std::string&, const std::string&, MoonrakerDeviceInfo& info, std::string&) const override
     {
         info.dev_name = "Test printer";
         return true;
@@ -108,7 +97,6 @@ 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
@@ -162,17 +150,11 @@ public:
         return m_close_frames;
     }
 
-    // First byte the stream sent, or -1 until it has sent one.
+    // The printer answers a close frame before its own read completes, so the agent's stop can return first.
-    bool wait_for_first_byte()
+    bool wait_for_close_frames(int count)
     {
         std::unique_lock<std::mutex> lock(m_mutex);
-        return m_changed.wait_for(lock, 10s, [&] { return m_first_byte >= 0; });
+        return m_changed.wait_for(lock, 10s, [&] { return m_close_frames >= count; });
-    }
-
-    int first_byte()
-    {
-        std::lock_guard<std::mutex> lock(m_mutex);
-        return m_first_byte;
     }
 
     // Hangs up every connection that is waiting.
@@ -207,20 +189,6 @@ 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;
@@ -316,6 +284,7 @@ private:
                 if (ec == websocket::error::closed) {
                     std::lock_guard<std::mutex> lock(m_mutex);
                     ++m_close_frames;
+                    m_changed.notify_all();
                 }
                 if (ec)
                     reading = false;
@@ -374,7 +343,6 @@ 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;
 };
 
@@ -417,15 +385,12 @@ 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_stream(printer.base_url()); }
+    void start() { agent.start_status_stream("printer", 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_stream(); });
+        auto stopped       = std::async(std::launch::async, [this] { agent.stop_status_stream(); });
         const bool in_time = stopped.wait_for(limit) == std::future_status::ready;
         printer.release();
         stopped.wait();
@@ -481,16 +446,6 @@ 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.
@@ -502,6 +457,7 @@ TEST_CASE("Stopping the status stream sends the printer a close frame", "[Moonra
     REQUIRE(f.printer.wait_for_ready_connections(1));
 
     CHECK(f.stops_within(3s));
+    CHECK(f.printer.wait_for_close_frames(1));
     CHECK(f.printer.close_frames() == 1);
 }
 
@@ -567,7 +523,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_stream();
+            f.agent.stop_status_stream();
             stopped.set_value();
         });
     });
@@ -625,12 +581,9 @@ 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));
 
-    // disconnect_printer joins the worker running the stalled query, so it is called aside and the
+    f.agent.disconnect_printer();
-    // 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_audit.cpp

@@ -43,7 +43,7 @@ void seed_denied_keywords()
 
 } // namespace
 
-TEST_CASE("Plugin audit denies app config and token filenames anywhere", "[audit]")
+TEST_CASE("Plugin audit denies host-managed filenames anywhere", "[audit]")
 {
     seed_denied_names();
     const PluginAuditManager& mgr = PluginAuditManager::instance();
@@ -55,6 +55,7 @@ TEST_CASE("Plugin audit denies app config and token filenames anywhere", "[audit
         CHECK(mgr.is_denied_filename(fs::path(SLIC3R_APP_KEY ".ini")));
         CHECK(mgr.is_denied_filename(fs::path(GCODEVIEWER_APP_KEY ".ini")));
         CHECK(mgr.is_denied_filename(fs::path(secret_constants::USER_SECRET_FILENAME)));
+        CHECK(mgr.is_denied_filename(fs::path(".install_state.json")));
     }
 
     SECTION("companions holding the same secrets are denied by the prefix rule")
@@ -110,6 +111,7 @@ TEST_CASE("Plugin audit deny beats allowed roots", "[audit]")
 
     const fs::path conf  = fs::path(data_dir()) / (SLIC3R_APP_KEY ".conf");
     const fs::path token = fs::path(data_dir()) / secret_constants::USER_SECRET_FILENAME;
+    const fs::path install_state = fs::path(data_dir()) / "plugins" / "example" / ".install_state.json";
 
     SECTION("a non-denied file inside the allowed root is writable (root really grants writes)")
     {
@@ -150,6 +152,17 @@ TEST_CASE("Plugin audit deny beats allowed roots", "[audit]")
         CHECK_FALSE(decision.allowed);
     }
 
+    SECTION("plugin install state is blocked for reads and writes despite the allowed root")
+    {
+        AuditDecision read_decision = mgr.check_open(install_state.string(), "r");
+        CHECK_FALSE(read_decision.allowed);
+        CHECK(read_decision.reason == "denied filename");
+
+        AuditDecision write_decision = mgr.check_open(install_state.string(), "w");
+        CHECK_FALSE(write_decision.allowed);
+        CHECK(write_decision.reason == "denied filename");
+    }
+
     SECTION("a traversal path resolving to the config is blocked")
     {
         const fs::path traversal = fs::path(data_dir()) / "plugins" / ".." / (SLIC3R_APP_KEY ".conf");

tests/slic3rutils/test_plugin_lifecycle.cpp

@@ -615,8 +615,22 @@ 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;
+    {
-    fs::remove_all(package_root / "__pycache__", ec);
+        // The rewrite can keep the old mtime and size, so drop the bytecode wherever the
+        // 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,30 +1,18 @@
 #include <catch2/catch_all.hpp>
 
-#include <functional>
-#include <slic3r/Utils/BBLPrinterAgent.hpp>
-#include <slic3r/Utils/IPrinterAgent.hpp>
-#include <slic3r/Utils/MoonrakerPrinterAgent.hpp>
 #include <memory>
 #include <slic3r/Utils/NetworkAgentFactory.hpp>
 
 #include <catch2/catch_test_macros.hpp>
 #include <pybind11/pytypes.h>
 #include <catch2/catch_message.hpp>
-#include "catch2/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; }
@@ -32,390 +20,12 @@ 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("printer-agent registry register / lookup / duplicate-reject", "[PrinterAgent]")
+TEST_CASE("unit: printer-agent registry register / lookup / duplicate-reject", "[registry][unit]")
 {
     // 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
@@ -459,7 +69,7 @@ TEST_CASE("printer-agent registry register / lookup / duplicate-reject", "[Print
 // 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("orca.printer_agent binding surface", "[integration][Python]")
+TEST_CASE("integration: orca.printer_agent binding surface", "[integration][Python]")
 {
     py::module_ orca = import_orca_module();
 
@@ -510,7 +120,7 @@ TEST_CASE("orca.printer_agent binding surface", "[integration][Python]")
 // them in the lightweight embedded-interpreter test catches binding breakage
 // before the plugin-loader test needs to run.
 // ===========================================================================
-TEST_CASE("orca plugin-registration API surface + discovery-context guards", "[integration][Python]")
+TEST_CASE("integration: orca plugin-registration API surface + discovery-context guards", "[integration][Python]")
 {
     py::module_ orca = import_orca_module();
 

tests/slic3rutils/test_qidi_printer_agent.cpp

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