AMS Sync, Filament Mapping, Storage Tab (#16156)

## Summary

Adds the remaining OrcaPrinterAgent work on top of feature/OrcaSonar:
connector capability gating, AMS filament mapping, and the printer
Storage tab. Contains no changes to the other printer agents (Moonraker,
Qidi, Snapmaker, BBL, Creality) — that refactor belongs to its own
branch.

## Changes

Capability gating (IPrinterAgent, OrcaPrinterAgent)

• Parse supported_features, capabilities.protocol.features, and
supported_commands from get_capabilities, including replies without a
flags block.
• Add supports_command, supports_feature, and uses_filament_mapping
queries with defaults that preserve existing agent behavior.
• Gate macro-backed AMS commands on fms plus the advertised command, and
slot metadata writes on filament_slots. Unknown capability means not
supported.

## AMS filament mapping

• Serialize ams_mapping2 into print.gcode_file.filament_mapping, keyed
by array position, dropping {255,255}; omit when empty so unmapped
prints stay byte-identical.
• Refuse a mapped print visibly until the correlation flag and
filament_mapping capability are satisfied, and refuse partially mapped
prints with an unmapped used filament. The GUI predicate shares the
serializer's definition.
• Resolve printer-set trays to the matching Generic preset by material
type and color; skip forced external-spool selection on printers without
an AMS.
• start_local_print_with_record returns non-success so PrintJob falls
back to start_print.

## AMS device UI on non-Bambu agents

• Resolve the printer model from the agent model id or selected profile
so the AMS Materials Setting dropdown and Confirm button work;
third-party trays keep editable temps.
• Render explicitly-empty trays as "Empty" via a wire-derived is_empty,
keeping the slot editable.
• Hide flow-dynamics K/N controls for non-Bambu agents, leaving Bambu
behavior unchanged.

## Storage tab (printer G-code files)

• New IPrinterAgent file APIs — list_printer_files,
get_printer_file_thumbnail, delete_printer_file,
get_printer_file_metadata — with ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED
defaults.
• NetworkAgent forwards to the bound agent; OrcaPrinterAgent implements
them against /server/files.
• New StoragePanel / OrcaFilesPanel and a Printer/ file-grid abstraction
(IFileGridModel, RemoteFileGridModel, BambuFileGridModel).

## Tests

Covers serializer keying/omission, GUI/agent gate agreement, payload
shape, capability parsing and per-command AMS gating, model resolution,
empty-tray classification, and AMS sync.

src/libslic3r/PresetBundle.cpp

@@ -3893,42 +3893,58 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
         ams_array_maps.push_back(temp);
         index++;
         if (filament_id.empty()) {
-            if (use_map) {
-                for (int j = maps.size() - 1; j >= 0; j--) {
-                    if (maps[j].slot_id == slot_id && maps[j].ams_id == ams_id) {
-                        maps.erase(j);
+            // A tray written by the printer UI carries a material type but no
+            // OrcaSlicer preset id. Resolve it to the matching Generic preset with
+            // the tray's own color instead of dropping it (direct sync) or forcing
+            // "Generic PLA" (mapping sync). Placeholders and typeless trays keep
+            // the previous behavior.
+            const auto tray_type = ams.opt_string("filament_type", 0u);
+            if (is_placeholder || tray_type.empty()) {
+                if (use_map) {
+                    for (int j = maps.size() - 1; j >= 0; j--) {
+                        if (maps[j].slot_id == slot_id && maps[j].ams_id == ams_id) {
+                            maps.erase(j);
+                        }
                     }
+                    ams_filament_presets.push_back("Generic PLA");//for unknow matieral
+                    auto default_unknown_color = "#CECECE";
+                    ams_filament_colors.push_back(default_unknown_color);
+                    ams_filament_color_types.push_back("1");
+                    if (filament_multi_color.size() == 0) {
+                        filament_multi_color.push_back(default_unknown_color);
+                    }
+                    ams_multi_color_filment.push_back(filament_multi_color);
+                } else if (is_placeholder) {
+                    // Orca: push placeholders to keep index alignment with ams_infos
+                    ams_filament_presets.push_back("");
+                    ams_filament_colors.push_back("");
+                    ams_filament_color_types.push_back("");
+                    ams_multi_color_filment.push_back({});
                 }
-                ams_filament_presets.push_back("Generic PLA");//for unknow matieral
-                auto default_unknown_color = "#CECECE";
-                ams_filament_colors.push_back(default_unknown_color);
-                ams_filament_color_types.push_back("1");
-                if (filament_multi_color.size() == 0) {
-                    filament_multi_color.push_back(default_unknown_color);
-                }
-                ams_multi_color_filment.push_back(filament_multi_color);
-            } else if (is_placeholder) {
-                // Orca: push placeholders to keep index alignment with ams_infos
-                ams_filament_presets.push_back("");
-                ams_filament_colors.push_back("");
-                ams_filament_color_types.push_back("");
-                ams_multi_color_filment.push_back({});
+                continue;
             }
-            continue;
         }
         if (!filament_changed && this->filament_presets.size() > ams_filament_presets.size()) {
             ams_filament_presets.push_back(this->filament_presets[ams_filament_presets.size()]);
             ams_filament_colors.push_back(filament_color);
             ams_filament_color_types.push_back(filament_color_type);
             ams_multi_color_filment.push_back(filament_multi_color);
+            ams_infos.back().valid = true;
             continue;
         }
         bool has_type = false;
         auto filament_type = ams.opt_string("filament_type", 0u);
-        auto iter = std::find_if(filaments.begin(), filaments.end(), [this, &filament_id, &has_type, filament_type](auto &f) {
-            has_type |= f.config.opt_string("filament_type", 0u) == filament_type;
-            return f.is_compatible && filaments.get_preset_base(f) == &f && f.filament_id == filament_id; });
-        warn_ambiguous_filament_id_match(filaments, iter, filament_id);
+        auto iter = filaments.end();
+        if (!filament_id.empty()) {
+            iter = std::find_if(filaments.begin(), filaments.end(), [this, &filament_id, &has_type, filament_type](auto &f) {
+                has_type |= f.config.opt_string("filament_type", 0u) == filament_type;
+                return f.is_compatible && filaments.get_preset_base(f) == &f && f.filament_id == filament_id; });
+            warn_ambiguous_filament_id_match(filaments, iter, filament_id);
+        } else {
+            // The material type is the only identity a printer-set tray carries.
+            has_type = std::any_of(filaments.begin(), filaments.end(), [&filament_type](auto &f) {
+                return f.is_compatible && f.config.opt_string("filament_type", 0u) == filament_type; });
+        }
         if (iter == filaments.end()) {
             BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": filament_id %1% not found or system or compatible") % filament_id;
             if (!filament_type.empty()) {
@@ -3975,6 +3991,7 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                     ams_filament_colors.push_back(filament_color);
                     ams_filament_color_types.push_back(filament_color_type);
                     ams_multi_color_filment.push_back(filament_multi_color);
+                    ams_infos.back().valid = true;
                     unknowns.emplace_back(&ams, has_type ? L("The filament may not be compatible with the current machine settings. Generic filament presets will be used.") :
                                                            L("The filament model is unknown. Still using the previous filament preset."));
                     continue;
@@ -4001,6 +4018,7 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
         ams_filament_colors.push_back(filament_color);
         ams_filament_color_types.push_back(filament_color_type);
         ams_multi_color_filment.push_back(filament_multi_color);
+        ams_infos.back().valid = true;
     }
     if (ams_filament_presets.empty())
         return 0;
@@ -4440,9 +4458,21 @@ std::vector<std::vector<DynamicPrintConfig>> PresetBundle::get_extruder_filament
     return filament_infos;
 }
 
-// ORCA TODO: currently, this function assumes the printer name follows the pattern of "<printer_model> <nozzle_diameter>", e.g.
-// printer_type: "Bambu Lab X2D", nozzle_diameter_str: "0.4 nozzle" => printer_name: "Bambu Lab X2D 0.4 nozzle". If the printer name does
-// not follow this pattern, the function may not work correctly.
+std::string PresetBundle::get_printer_model_display_name(const std::string &model_id) const
+{
+    if (model_id.empty())
+        return {};
+    for (const auto &vendor_entry : vendors) {
+        for (const auto &model : vendor_entry.second.models) {
+            if (model.model_id == model_id)
+                return model.name;
+        }
+    }
+    return {};
+}
+
+// ORCA TODO: this assumes printer names follow "<printer_model> <nozzle_diameter>", e.g.
+// "Bambu Lab X2D 0.4 nozzle". Other naming schemes may not resolve correctly.
 std::set<std::string> PresetBundle::get_printer_names_by_printer_type_and_nozzle(const std::string &printer_type, std::string nozzle_diameter_str, bool system_only)
 {
     std::set<std::string> printer_names;
@@ -4464,7 +4494,9 @@ std::set<std::string> PresetBundle::get_printer_names_by_printer_type_and_nozzle
         if (printer_it->name.find(nozzle_diameter_str) != std::string::npos) printer_names.insert(printer_it->name);
     }
 
-    assert(printer_names.size() == 1);
+    // No match is normal for a connected machine the user has not installed; only an
+    // ambiguous match is a bug (the caller assumes one preset per model and nozzle).
+    assert(printer_names.size() <= 1);
 
     for (auto& printer_name : printer_names) {
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << __LINE__ << " printer name: " << printer_name;
@@ -4477,8 +4509,8 @@ std::vector<Preset *> PresetBundle::get_filament_presets_for_machine(const std::
                                                                     const std::string &nozzle_diameter_str,
                                                                     bool               include_user_presets)
 {
-    // Printer model plus nozzle diameter is expected to resolve to a single system printer preset;
-    // get_printer_names_by_printer_type_and_nozzle asserts as much in debug builds.
+    // Printer model plus nozzle diameter normally resolves to a single system printer preset.
+    // Zero matches is normal for a connected machine the user never installed.
     const std::set<std::string> printer_names = get_printer_names_by_printer_type_and_nozzle(printer_type, nozzle_diameter_str);
     const Preset *printer = printer_names.empty() ? nullptr : printers.find_preset(*printer_names.begin());
     if (printer == nullptr)

src/libslic3r/PresetBundle.hpp

@@ -411,6 +411,9 @@ public:
 
     std::vector<std::vector<DynamicPrintConfig>> get_extruder_filament_info() const;
 
+    // Resolve a vendor model id (an agent-reported machine identity) to the display name
+    // printer profiles use as printer_model. Empty when no loaded vendor declares it.
+    std::string get_printer_model_display_name(const std::string &model_id) const;
     std::set<std::string> get_printer_names_by_printer_type_and_nozzle(const std::string &printer_type, std::string nozzle_diameter_str, bool system_only = true);
     // Orca: the root filament presets a connected machine can use, resolved with the rule the rest
     // of the app applies (is_compatible_with_printer): an empty compatible_printers means every

src/slic3r/CMakeLists.txt

@@ -366,6 +366,10 @@ set(SLIC3R_GUI_SOURCES
     GUI/MarkdownTip.hpp
     GUI/MediaFilePanel.cpp
     GUI/MediaFilePanel.h
+    GUI/OrcaFilesPanel.cpp
+    GUI/OrcaFilesPanel.h
+    GUI/StoragePanel.cpp
+    GUI/StoragePanel.h
     GUI/MediaPlayCtrl.cpp
     GUI/MediaPlayCtrl.h
     GUI/WebRtcMediaController.cpp
@@ -455,6 +459,11 @@ set(SLIC3R_GUI_SOURCES
     GUI/PresetHints.hpp
     GUI/PrinterCloudAuthDialog.cpp
     GUI/PrinterCloudAuthDialog.hpp
+    GUI/Printer/BambuFileGridModel.cpp
+    GUI/Printer/BambuFileGridModel.h
+    GUI/Printer/IFileGridModel.h
+    GUI/Printer/RemoteFileGridModel.cpp
+    GUI/Printer/RemoteFileGridModel.h
     GUI/Printer/PrinterFileSystem.cpp
     GUI/Printer/PrinterFileSystem.h
     GUI/PrinterWebView.cpp
@@ -770,8 +779,12 @@ set(SLIC3R_GUI_SOURCES
     Utils/ICameraSignalingChannel.hpp
     Utils/OrcaCloudServiceAgent.cpp
     Utils/OrcaCloudServiceAgent.hpp
+    Utils/OrcaMqttConnection.cpp
+    Utils/OrcaMqttConnection.hpp
     Utils/OrcaPrinterAgent.cpp
     Utils/OrcaPrinterAgent.hpp
+    Utils/OrcaCloudSignalingChannel.cpp
+    Utils/OrcaCloudSignalingChannel.hpp
     Utils/QidiPrinterAgent.cpp
     Utils/QidiPrinterAgent.hpp
     Utils/SnapmakerPrinterAgent.cpp
@@ -911,7 +924,7 @@ target_include_directories(libslic3r_gui PRIVATE Utils ${CMAKE_CURRENT_BINARY_DI
 
 if (WIN32)
     target_include_directories(libslic3r_gui SYSTEM PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../deps/WebView2/include)
-    target_link_libraries(libslic3r_gui Advapi32)
+    target_link_libraries(libslic3r_gui Advapi32 Crypt32)
 endif()
 
 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SLIC3R_GUI_SOURCES})

src/slic3r/GUI/AMSDryControl.cpp

@@ -7,6 +7,7 @@
 #include "slic3r/GUI/DeviceCore/DevExtruderSystem.h"
 
 #include "slic3r/GUI/DeviceCore/DevManager.h"
+#include "slic3r/GUI/DeviceManager.hpp"
 
 #include "slic3r/GUI/MsgDialog.hpp"
 
@@ -1633,8 +1634,16 @@ int AMSDryCtrWin::update_filament_list(DevAms* dev_ams, MachineObject* obj)
         stream << std::fixed << std::setprecision(1) << obj->GetExtderSystem()->GetNozzleDiameter(extruder_id);
         std::string nozzle_diameter_str = stream.str();
 
+        // The connected device's model may not resolve (OrcaSonar's is optional); the
+        // helper falls back to the selected profile so the list is never empty.
+        const std::string filament_printer_model = resolve_filament_printer_model(obj->printer_type, preset_bundle);
+        if (filament_printer_model.empty()) {
+            BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << " cannot resolve a printer model for the filament list";
+            return false;
+        }
+
         for (Preset *filament_it : preset_bundle->get_filament_presets_for_machine(
-                 DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str, obj->is_support_user_preset)) {
+                 filament_printer_model, nozzle_diameter_str, obj->is_support_user_preset)) {
             if (!filament_id_set.insert(filament_it->filament_id).second)
                 continue;
             const std::string filament_alias = filaments.get_preset_alias(*filament_it, true);

src/slic3r/GUI/AMSMaterialsSetting.cpp

@@ -472,6 +472,11 @@ void AMSMaterialsSetting::update_filament_editing(bool is_printing)
         m_button_confirm->Show(true);
     }
 
+    // A third-party tray owns its temp range; BBL RFID trays keep the read-only preset values.
+    const bool can_edit = !is_printing || obj->is_support_filament_setting_inprinting;
+    m_input_nozzle_min->Enable(m_is_third && can_edit);
+    m_input_nozzle_max->Enable(m_is_third && can_edit);
+
     if (!m_is_third) {
         m_tip_readonly->SetLabelText(wxEmptyString);
         m_tip_readonly->Hide();
@@ -494,6 +499,8 @@ void AMSMaterialsSetting::update_filament_editing(bool is_printing)
     if (m_view_only) { // Orca: view-only (2D laser/cut) — lock every edit control and hide apply/reset
         m_comboBox_filament->Enable(false);
         m_comboBox_cali_result->Enable(false);
+        m_input_nozzle_min->Enable(false);
+        m_input_nozzle_max->Enable(false);
         m_input_k_val->Enable(false);
         m_input_n_val->Enable(false);
         m_button_confirm->Hide();
@@ -543,7 +550,7 @@ void AMSMaterialsSetting::on_select_reset(wxCommandEvent& event) {
         }
 
         // set k / n value
-        if (obj->cali_version <= -1 && obj->get_printer_series() == PrinterSeries::SERIES_P1P) {
+        if (obj->supports_extrusion_cali() && obj->cali_version <= -1 && obj->get_printer_series() == PrinterSeries::SERIES_P1P) {
             // set extrusion cali ratio
             int cali_tray_id = ams_id * 4 + slot_id;
 
@@ -564,7 +571,7 @@ void AMSMaterialsSetting::on_select_reset(wxCommandEvent& event) {
             }
             obj->command_extrusion_cali_set(cali_tray_id, "", "", k, n);
         }
-        else {
+        else if (obj->supports_extrusion_cali()) {
             PACalibIndexInfo select_index_info;
             int tray_id = ams_id * 4 + slot_id;
             if (is_virtual_tray()) {
@@ -746,7 +753,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
     wxString k_text = m_input_k_val->GetTextCtrl()->GetValue();
     wxString n_text = m_input_n_val->GetTextCtrl()->GetValue();
 
-    if (obj->cali_version <= -1 && (obj->get_printer_series() != PrinterSeries::SERIES_X1) && !ExtrusionCalibration::check_k_validation(k_text)) {
+    if (obj->supports_extrusion_cali() && obj->cali_version <= -1 && (obj->get_printer_series() != PrinterSeries::SERIES_X1) && !ExtrusionCalibration::check_k_validation(k_text)) {
         wxString k_tips = wxString::Format(_L("Please input a valid value (K in %.1f~%.1f)"), MIN_PA_K_VALUE, MAX_PA_K_VALUE);
         wxString kn_tips = wxString::Format(_L("Please input a valid value (K in %.1f~%.1f, N in %.1f~%.1f)"), MIN_PA_K_VALUE, MAX_PA_K_VALUE, 0.6, 2.0);
         MessageDialog msg_dlg(nullptr, k_tips, wxEmptyString, wxICON_WARNING | wxOK);
@@ -776,7 +783,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
             vt_tray = VIRTUAL_TRAY_DEPUTY_ID;
         }
 
-        if (obj->cali_version >= 0) {
+        if (obj->supports_extrusion_cali() && obj->cali_version >= 0) {
             PACalibIndexInfo select_index_info;
             select_index_info.tray_id = vt_tray;
             select_index_info.ams_id = ams_id;
@@ -795,7 +802,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
 
             CalibUtils::select_PA_calib_result(select_index_info);
         }
-        else {
+        else if (obj->supports_extrusion_cali()) {
             obj->command_extrusion_cali_set(vt_tray, "", "", k, n);
         }
     }
@@ -817,7 +824,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
             ;
         }
 
-        if (obj->cali_version >= 0) {
+        if (obj->supports_extrusion_cali() && obj->cali_version >= 0) {
             PACalibIndexInfo select_index_info;
             select_index_info.tray_id = cali_tray_id;
             select_index_info.ams_id = ams_id;
@@ -836,7 +843,7 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
 
             CalibUtils::select_PA_calib_result(select_index_info);
         }
-        else {
+        else if (obj->supports_extrusion_cali()) {
             obj->command_extrusion_cali_set(cali_tray_id, "", "", k, n);
         }
     }
@@ -932,7 +939,12 @@ bool AMSMaterialsSetting::is_virtual_tray()
 
 void AMSMaterialsSetting::update_widgets()
 {
-    if (obj && obj->get_printer_series() == PrinterSeries::SERIES_X1 && obj->cali_version <= -1) {
+    if (obj && !obj->supports_extrusion_cali()) {
+        // No printer-side K/N records: do not offer them.
+        m_panel_normal->Show();
+        m_panel_kn->Hide();
+    }
+    else if (obj && obj->get_printer_series() == PrinterSeries::SERIES_X1 && obj->cali_version <= -1) {
         // Low version firmware does not display k value
         m_panel_kn->Hide();
     }
@@ -993,6 +1005,9 @@ void AMSMaterialsSetting::Popup(wxString filament, wxString sn, wxString temp_mi
 
     m_input_k_val->GetTextCtrl()->SetValue(k);
     m_input_n_val->GetTextCtrl()->SetValue(n);
+    // Tray values are re-supplied by every caller; clear so a previous popup cannot leak in.
+    m_input_nozzle_min->GetTextCtrl()->SetValue(wxEmptyString);
+    m_input_nozzle_max->GetTextCtrl()->SetValue(wxEmptyString);
 
     wxArrayString filament_items;
     wxString bambu_filament_name;
@@ -1016,11 +1031,14 @@ void AMSMaterialsSetting::Popup(wxString filament, wxString sn, wxString temp_mi
     }
     stream << std::fixed << std::setprecision(1) << machine_diameter;
     std::string nozzle_diameter_str = stream.str();
+    // OrcaSonar's model id is optional, so the device model alone can resolve to nothing;
+    // the helper falls back to the selected profile so the dropdown is never empty.
+    const std::string filament_printer_model = resolve_filament_printer_model(obj->printer_type, preset_bundle);
 
-    if (preset_bundle) {
+    if (preset_bundle && !filament_printer_model.empty()) {
         BOOST_LOG_TRIVIAL(trace) << "system_preset_bundle filament number=" << preset_bundle->filaments.size();
         for (Preset *filament_it : preset_bundle->get_filament_presets_for_machine(
-                 DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str, obj->is_support_user_preset)) {
+                 filament_printer_model, nozzle_diameter_str, obj->is_support_user_preset)) {
             if (!filament_id_set.insert(filament_it->filament_id).second)
                 continue;
             const std::string alias = preset_bundle->filaments.get_preset_alias(*filament_it, true);
@@ -1087,6 +1105,12 @@ void AMSMaterialsSetting::Popup(wxString filament, wxString sn, wxString temp_mi
         else {
             m_comboBox_filament->Show();
             m_readonly_filament->Hide();
+            // A printer-set tray carries its own temps; the preset selection only fills
+            // them when the tray has none.
+            if (!temp_min.IsEmpty() && temp_min != "0")
+                m_input_nozzle_min->GetTextCtrl()->SetValue(temp_min);
+            if (!temp_max.IsEmpty() && temp_max != "0")
+                m_input_nozzle_max->GetTextCtrl()->SetValue(temp_max);
         }
 
         if (obj->cali_version >= 0) {
@@ -1223,7 +1247,12 @@ void AMSMaterialsSetting::Popup(wxString filament, wxString sn, wxString temp_mi
         }
     }
 
+    if (filament_items.IsEmpty())
+        BOOST_LOG_TRIVIAL(warning) << "ams_materials_setting: no filament presets for printer model \""
+                                   << filament_printer_model << "\" at nozzle " << nozzle_diameter_str;
+
     m_comboBox_filament->Set(filament_items);
+    m_comboBox_from_printer = true;
     m_comboBox_filament->SetSelection(selection_idx);
     post_select_event(selection_idx);
 
@@ -1231,9 +1260,6 @@ void AMSMaterialsSetting::Popup(wxString filament, wxString sn, wxString temp_mi
         m_comboBox_filament->SetValue(wxEmptyString);
     }
 
-    // Set the flag whether to open the filament setting dialog from the device page
-    m_comboBox_filament->SetClientData(new int(1));
-
     update();
     Layout();
     Fit();
@@ -1277,50 +1303,53 @@ int AMSMaterialsSetting::get_filament_variant_index(const Preset &filament, cons
 
 void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
 {
-    // Get the flag whether to open the filament setting dialog from the device page
-    int* from_printer = static_cast<int*>(m_comboBox_filament->GetClientData());
+    // True for the popup's own initial selection: the dialog pre-filled the tray's
+    // temps, so the matching preset must not overwrite them.
+    const bool initial_printer_selection = m_comboBox_from_printer;
 
     m_filament_type = "";
     PresetBundle* preset_bundle = wxGetApp().preset_bundle;
+    std::string filament_printer_model;
     if (preset_bundle) {
         std::ostringstream stream;
         if (obj) {
-            // Defensive: this dialog is opened only from StatusPanel (BBL-only) today, so the fallback fires
-            // only during the brief BBL startup window before firmware reports nozzle info. Without this,
-            // the "0.0" lookup string returns an empty set and filament lookup yields no results.
+            // Use the selected profile's nozzle diameter until the connected device reports one.
             float machine_diameter = obj->GetExtderSystem()->GetNozzleDiameter(0);
             if (machine_diameter == 0.0f) {
                 const ConfigOption *opt = preset_bundle->printers.get_selected_preset().config.option("nozzle_diameter");
                 if (opt) machine_diameter = static_cast<const ConfigOptionFloats *>(opt)->values[0];
             }
             stream << std::fixed << std::setprecision(1) << machine_diameter;
+            filament_printer_model = resolve_filament_printer_model(obj->printer_type, preset_bundle);
         }
         std::string nozzle_diameter_str = stream.str();
         // Resolve the selection against the same list Popup() built the dropdown from, so the two
         // halves of the dialog cannot disagree about which filaments this machine can use.
         const std::string selected = m_comboBox_filament->GetValue().ToStdString();
-        if (!selected.empty()) {
+        if (!selected.empty() && !filament_printer_model.empty()) {
             const std::string filament_id = map_filament_items[selected].filament_id;
             for (Preset *it : preset_bundle->get_filament_presets_for_machine(
-                     DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str, obj->is_support_user_preset)) {
+                     filament_printer_model, nozzle_diameter_str, obj->is_support_user_preset)) {
                 if (it->filament_id != filament_id)
                     continue;
-                // ) if nozzle_temperature_range is found
-                const int variant_index = get_filament_variant_index(*it, nozzle_diameter_str);
-                ConfigOption* opt_min = it->config.option("nozzle_temperature_range_low");
-                if (opt_min) {
-                    ConfigOptionInts* opt_min_ints = dynamic_cast<ConfigOptionInts*>(opt_min);
-                    if (opt_min_ints) {
-                        wxString text_nozzle_temp_min = wxString::Format("%d", opt_min_ints->get_at(variant_index));
-                        m_input_nozzle_min->GetTextCtrl()->SetValue(text_nozzle_temp_min);
+                if (!initial_printer_selection) {
+                    // ) if nozzle_temperature_range is found
+                    const int variant_index = get_filament_variant_index(*it, nozzle_diameter_str);
+                    ConfigOption* opt_min = it->config.option("nozzle_temperature_range_low");
+                    if (opt_min) {
+                        ConfigOptionInts* opt_min_ints = dynamic_cast<ConfigOptionInts*>(opt_min);
+                        if (opt_min_ints) {
+                            wxString text_nozzle_temp_min = wxString::Format("%d", opt_min_ints->get_at(variant_index));
+                            m_input_nozzle_min->GetTextCtrl()->SetValue(text_nozzle_temp_min);
+                        }
                     }
-                }
-                ConfigOption* opt_max = it->config.option("nozzle_temperature_range_high");
-                if (opt_max) {
-                    ConfigOptionInts* opt_max_ints = dynamic_cast<ConfigOptionInts*>(opt_max);
-                    if (opt_max_ints) {
-                        wxString text_nozzle_temp_max = wxString::Format("%d", opt_max_ints->get_at(variant_index));
-                        m_input_nozzle_max->GetTextCtrl()->SetValue(text_nozzle_temp_max);
+                    ConfigOption* opt_max = it->config.option("nozzle_temperature_range_high");
+                    if (opt_max) {
+                        ConfigOptionInts* opt_max_ints = dynamic_cast<ConfigOptionInts*>(opt_max);
+                        if (opt_max_ints) {
+                            wxString text_nozzle_temp_max = wxString::Format("%d", opt_max_ints->get_at(variant_index));
+                            m_input_nozzle_max->GetTextCtrl()->SetValue(text_nozzle_temp_max);
+                        }
                     }
                 }
                 ConfigOption* opt_type = it->config.option("filament_type");
@@ -1359,13 +1388,16 @@ void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
         m_button_confirm->Disable(); // ORCA No need to change style
         m_comboBox_cali_result->Clear();
         m_comboBox_cali_result->SetValue(wxEmptyString);
-        m_input_k_val->GetTextCtrl()->SetValue(wxEmptyString);
-        m_input_n_val->GetTextCtrl()->SetValue(wxEmptyString);
-        m_comboBox_filament->SetClientData(new int(0));
+        if (!initial_printer_selection) {
+            m_input_k_val->GetTextCtrl()->SetValue(wxEmptyString);
+            m_input_n_val->GetTextCtrl()->SetValue(wxEmptyString);
+        }
+        m_comboBox_from_printer = false;
         return;
     }
     else {
-        m_button_confirm->Enable(true);  // ORCA No need to change style
+        if (!m_view_only)
+            m_button_confirm->Enable(true);  // ORCA No need to change style
     }
 
     //filament id
@@ -1389,6 +1421,9 @@ void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
         }
     }
 
+    if (!ams_filament_id.empty())
+        m_clr_picker->is_empty(false);
+
     wxArrayString items;
     m_pa_profile_items.clear();
     m_comboBox_cali_result->SetValue(wxEmptyString);
@@ -1444,7 +1479,7 @@ void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
 
         m_comboBox_cali_result->Set(items);
         if (ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID) {
-            if (from_printer && (*from_printer == 1)) {
+            if (initial_printer_selection) {
                 for (auto slot : obj->vt_slot) {
                     if (slot.id == std::to_string(ams_id))
                         cali_select_idx = CalibUtils::get_selected_calib_idx(m_pa_profile_items, slot.cali_idx);
@@ -1461,10 +1496,11 @@ void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
             }
         }
         else {
-            if (from_printer && (*from_printer == 1)) {
+            if (initial_printer_selection) {
                 DevAmsTray* selected_tray = this->obj->GetFilaSystem()->GetAmsTray(std::to_string(ams_id), std::to_string(slot_id));
                 if (!selected_tray)
                 {
+                    m_comboBox_from_printer = false;
                     return;
                 }
 
@@ -1495,7 +1531,7 @@ void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
     else {
         if (!ams_filament_id.empty()) {
             //m_input_k_val->GetTextCtrl()->SetValue("0.00");
-            m_input_k_val->Enable(true);
+            m_input_k_val->Enable(!m_view_only);
         }
         else {
             //m_input_k_val->GetTextCtrl()->SetValue("0.00");
@@ -1503,7 +1539,7 @@ void AMSMaterialsSetting::on_select_filament(wxCommandEvent &evt)
         }
     }
 
-    m_comboBox_filament->SetClientData(new int(0));
+    m_comboBox_from_printer = false;
 }
 
 void AMSMaterialsSetting::on_dpi_changed(const wxRect &suggested_rect)

src/slic3r/GUI/AMSMaterialsSetting.hpp

@@ -138,7 +138,7 @@ public:
     std::string    ams_filament_id;
     std::string    ams_setting_id;
 
-    bool           m_is_third;
+    bool           m_is_third = false;
     // Orca: view-only mode (laser/cut). When set, the dialog is inspectable but every
     // editing control is disabled and no command is sent.
     bool           m_view_only = false;
@@ -200,6 +200,9 @@ protected:
     wxStaticText*       m_n_param;
     TextInput*          m_input_n_val;
     int                 m_filament_selection;
+    // True while the popup's initial, printer-driven selection is being handled; it
+    // keeps that selection from overwriting the tray's own temps with preset temps.
+    bool                m_comboBox_from_printer = false;
 
     int m_pa_cali_select_id = 0;
 

src/slic3r/GUI/AMSSetting.cpp

@@ -530,7 +530,8 @@ void AMSSetting::on_insert_material_read(wxCommandEvent &event)
     bool tray_read_opt = m_checkbox_Insert_material_auto_read->GetValue();
     bool remain_opt = m_checkbox_remain->GetValue();
 
-    m_obj->command_ams_user_settings(start_read_opt, tray_read_opt, remain_opt);
+    if (m_obj->command_ams_user_settings(start_read_opt, tray_read_opt, remain_opt) != 0)
+        UpdateByObj(m_obj);
 
     m_sizer_Insert_material_tip_inline->Layout();
     Layout();
@@ -556,7 +557,8 @@ void AMSSetting::on_starting_read(wxCommandEvent &event)
     bool tray_read_opt  = m_checkbox_Insert_material_auto_read->GetValue();
     bool remain_opt = m_checkbox_remain->GetValue();
 
-    m_obj->command_ams_user_settings(start_read_opt, tray_read_opt, remain_opt);
+    if (m_obj->command_ams_user_settings(start_read_opt, tray_read_opt, remain_opt) != 0)
+        UpdateByObj(m_obj);
 
     m_sizer_starting_tip_inline->Layout();
     Layout();
@@ -570,7 +572,8 @@ void AMSSetting::on_remain(wxCommandEvent& event)
     bool start_read_opt = m_checkbox_starting_auto_read->GetValue();
     bool tray_read_opt = m_checkbox_Insert_material_auto_read->GetValue();
     bool remain_opt = m_checkbox_remain->GetValue();
-    m_obj->command_ams_user_settings(start_read_opt, tray_read_opt, remain_opt);
+    if (m_obj->command_ams_user_settings(start_read_opt, tray_read_opt, remain_opt) != 0)
+        UpdateByObj(m_obj);
     event.Skip();
 }
 
@@ -806,4 +809,4 @@ void AMSSettingArrangeAMSOrder::OnBtnRearrangeClicked(wxCommandEvent& event)
 }
 #endif
 
-}} // namespace Slic3r::GUI
+}} // namespace Slic3r::GUI

src/slic3r/GUI/CaliHistoryDialog.cpp

@@ -745,9 +745,15 @@ wxArrayString NewCalibrationHistoryDialog::get_all_filaments(const MachineObject
     std::string nozzle_diameter_str = stream.str();
 
     if (preset_bundle) {
+        // OrcaSonar's model id is optional; the helper falls back to the selected profile
+        // so the list is never empty.
+        const std::string filament_printer_model = resolve_filament_printer_model(obj->printer_type, preset_bundle);
+        if (filament_printer_model.empty())
+            return filament_items;
+
         BOOST_LOG_TRIVIAL(trace) << "system_preset_bundle filament number=" << preset_bundle->filaments.size();
         for (Preset *filament_it : preset_bundle->get_filament_presets_for_machine(
-                 DevPrinterConfigUtil::get_printer_display_name(obj->printer_type), nozzle_diameter_str, obj->is_support_user_preset)) {
+                 filament_printer_model, nozzle_diameter_str, obj->is_support_user_preset)) {
             if (!filament_id_set.insert(filament_it->filament_id).second)
                 continue;
             const std::string alias = preset_bundle->filaments.get_preset_alias(*filament_it, true);

src/slic3r/GUI/DeviceCore/DevFilaSystem.cpp

@@ -30,6 +30,8 @@
 #include "DevUtil.h"
 #include "DevUtilBackend.h"
 
+#include <algorithm>
+
 using namespace nlohmann;
 
 namespace Slic3r {
@@ -61,6 +63,15 @@ void DevAmsTray::UpdateColorFromStr(const std::string& color)
     }
 }
 
+void DevAmsTray::UpdateEmptyState(bool material_fields_present)
+{
+    const auto is_zero_or_empty = [](const std::string& value) {
+        return value.empty() || std::all_of(value.begin(), value.end(), [](char c) { return c == '0'; });
+    };
+    is_empty = material_fields_present && setting_id.empty() && m_fila_type.empty() &&
+               is_zero_or_empty(color) && is_zero_or_empty(tag_uid);
+}
+
 void DevAmsTray::reset()
 {
     tag_uid             = "";
@@ -82,6 +93,7 @@ void DevAmsTray::reset()
     k                   = 0.0f;
     n                   = 0.0f;
     is_bbl              = false;
+    is_empty            = false;
     hold_count          = 0;
     remain              = 0;
 }
@@ -681,7 +693,7 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                                 //std::string type            = (*tray_it)["tray_type"].get<std::string>();
                                 std::string type = MachineObject::setting_id_to_type(curr_tray->setting_id, (*tray_it)["tray_type"].get<std::string>());
                                 // curr_tray->setting_id is our OF id; GFS00/GFS01 are the printer's own support-filament ids.
-                                auto* agent = GUI::wxGetApp().getAgent();
+                                auto* agent = wxTheApp != nullptr ? GUI::wxGetApp().getAgent() : nullptr;
                                 const std::string printer_filament_id = agent ? agent->from_orca_filament_id(curr_tray->setting_id) : curr_tray->setting_id;
                                 if (printer_filament_id == "GFS00")
                                 {
@@ -781,6 +793,7 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                             {
                                 curr_tray->remain = -1;
                             }
+                            curr_tray->UpdateEmptyState(tray_it->contains("tray_info_idx") && tray_it->contains("tray_type"));
                             // The tray objects are reused across status updates. Reset this
                             // state when a previously empty slot receives a filament again.
                             curr_tray->is_slot_placeholder = tray_it->contains("tray_slot_placeholder");

src/slic3r/GUI/DeviceCore/DevFilaSystem.h

@@ -83,6 +83,7 @@ public:
     wxColour        wx_color;
     bool            is_bbl;
     bool            is_exists = false;
+    bool            is_empty = false;  // Explicitly reported as having no filament.
     bool            is_slot_placeholder = false;  // Orca: True for empty tray slots from pull-mode agents
     int             hold_count = 0;
     int             remain = 0;         // filament remain: 0 ~ 100
@@ -91,13 +92,15 @@ public:
     // operators
     bool operator==(DevAmsTray const& o) const
     {
-        return id == o.id && m_fila_type == o.m_fila_type && filament_setting_id == o.filament_setting_id && color == o.color;
+        return id == o.id && m_fila_type == o.m_fila_type && filament_setting_id == o.filament_setting_id &&
+               color == o.color && is_empty == o.is_empty;
     }
     bool operator!=(DevAmsTray const& o) const { return !operator==(o); }
 
     // setters
     void reset();
     void UpdateColorFromStr(const std::string& color);
+    void UpdateEmptyState(bool material_fields_present);
     void set_hold_count() { hold_count = HOLD_COUNT_MAX; }
 
     // getter

src/slic3r/GUI/DeviceManager.cpp

@@ -432,6 +432,32 @@ NozzleVolumeType convert_to_nozzle_type(const std::string &str)
     return res;
 }
 
+std::string resolve_filament_printer_model(const std::string& printer_type, PresetBundle* preset_bundle)
+{
+    if (!preset_bundle)
+        return {};
+
+    // Devices with a shipped printer config (Bambu) resolve directly.
+    if (const std::string display_name = DevPrinterConfigUtil::get_printer_display_name(printer_type); !display_name.empty())
+        return display_name;
+
+    // A vendor model id the device reported (SSDP modelNumber, manual binding).
+    if (!printer_type.empty()) {
+        if (const std::string model_name = preset_bundle->get_printer_model_display_name(printer_type); !model_name.empty())
+            return model_name;
+    }
+
+    // OrcaSonar's model id is optional; a generic device resolves against the selected profile.
+    if (const ConfigOptionString* model = preset_bundle->printers.get_selected_preset().config.opt<ConfigOptionString>("printer_model");
+        model && !model->value.empty()) {
+        BOOST_LOG_TRIVIAL(info) << "resolve_filament_printer_model: device type \"" << printer_type
+                                << "\" has no installed model; using the selected profile \"" << model->value << "\"";
+        return model->value;
+    }
+
+    return {};
+}
+
 wxString MachineObject::get_printer_type_display_str() const
 {
     std::string display_name = DevPrinterConfigUtil::get_printer_display_name(printer_type);
@@ -1734,6 +1760,10 @@ int MachineObject::check_resume_condition()
 }
 int MachineObject::command_ams_change_filament(bool load, std::string ams_id, std::string slot_id, int old_temp, int new_temp, std::optional<int> extruder_id)
 {
+    if (!printer_supports_command("print.ams_change_filament")) {
+        BOOST_LOG_TRIVIAL(warning) << "command_ams_change_filament: printer agent does not support the command";
+        return command_with_dialog(ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    }
     json j;
     try {
         auto tray_id = 0;
@@ -1777,6 +1807,10 @@ int MachineObject::command_ams_change_filament(bool load, std::string ams_id, st
 
 int MachineObject::command_ams_user_settings(bool start_read_opt, bool tray_read_opt, bool remain_flag)
 {
+    if (!printer_supports_command("print.ams_user_setting")) {
+        BOOST_LOG_TRIVIAL(warning) << "command_ams_user_settings: printer agent does not support the command";
+        return command_with_dialog(ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    }
     json j;
     j["print"]["command"] = "ams_user_setting";
     j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
@@ -1785,22 +1819,59 @@ int MachineObject::command_ams_user_settings(bool start_read_opt, bool tray_read
     j["print"]["tray_read_option"]      = tray_read_opt;
     j["print"]["calibrate_remain_flag"] = remain_flag;
 
-    m_fila_system->GetAmsSystemSetting().SetDetectOnInsertEnabled(tray_read_opt);
-    m_fila_system->GetAmsSystemSetting().SetDetectOnPowerupEnabled(start_read_opt);
-    m_fila_system->GetAmsSystemSetting().SetDetectRemainEnabled(remain_flag);
-    ams_user_setting_start = time(nullptr);
-
-    return this->publish_json(j);
+    const int rc = this->publish_json(j);
+    if (rc == 0) {
+        m_fila_system->GetAmsSystemSetting().SetDetectOnInsertEnabled(tray_read_opt);
+        m_fila_system->GetAmsSystemSetting().SetDetectOnPowerupEnabled(start_read_opt);
+        m_fila_system->GetAmsSystemSetting().SetDetectRemainEnabled(remain_flag);
+        ams_user_setting_start = time(nullptr);
+    }
+    return rc;
 }
 
 int MachineObject::command_ams_calibrate(int ams_id)
 {
     if (!m_agent) return -1;
+    if (!m_agent->owns_agent(printer_agent_id))
+        return command_with_dialog(ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
     return command_with_dialog(m_agent->command_ams_calibrate(get_dev_id(), ams_id, MachineObject::m_sequence_id++, is_lan_mode_printer()));
 }
 
+bool MachineObject::printer_supports_command(const char* command) const
+{
+    if (!command || !m_agent)
+        return false;
+    return m_agent->supports_command(printer_agent_id, get_dev_id(), command);
+}
+
+bool MachineObject::printer_uses_filament_mapping() const
+{
+    if (!m_agent)
+        return false;
+    // An unrecorded owner goes through owns_agent() like any other, because
+    // whichever agent is active is also the one formatting the payload. Only a
+    // recorded owner that differs from the active agent is a mismatch.
+    return m_agent->uses_filament_mapping(printer_agent_id);
+}
+
+bool MachineObject::printer_supports_feature(const char* feature) const
+{
+    return feature && m_agent && m_agent->supports_feature(printer_agent_id, get_dev_id(), feature);
+}
+
+bool MachineObject::supports_extrusion_cali() const
+{
+    // Devices with no agent id predate the agent split and keep the Bambu path.
+    return printer_agent_id.empty() || printer_agent_id == BBL_PRINTER_AGENT_ID;
+}
+
 int MachineObject::command_ams_filament_settings(int ams_id, int slot_id, std::string filament_id, std::string setting_id, std::string tray_color, std::string tray_type, int nozzle_temp_min, int nozzle_temp_max)
 {
+    if (!printer_supports_command("print.ams_filament_setting")) {
+        BOOST_LOG_TRIVIAL(warning) << "command_ams_filament_settings: printer agent does not support slot metadata updates";
+        return command_with_dialog(ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    }
+
     int tag_tray_id = 0;
     int tag_ams_id  = ams_id;
     int tag_slot_id = slot_id;
@@ -1835,6 +1906,10 @@ int MachineObject::command_ams_filament_settings(int ams_id, int slot_id, std::s
 int MachineObject::command_ams_refresh_rfid(int ams_id, int slot_id)
 {
     if (!m_agent) return -1;
+    if (!printer_supports_command("print.ams_get_rfid")) {
+        BOOST_LOG_TRIVIAL(warning) << "command_ams_refresh_rfid: printer agent does not support the command";
+        return command_with_dialog(ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    }
     return command_with_dialog(m_agent->command_ams_refresh_rfid(get_dev_id(), ams_id, slot_id, MachineObject::m_sequence_id++, is_lan_mode_printer()));
 }
 
@@ -1848,11 +1923,19 @@ int MachineObject::command_start_camera()
 int MachineObject::command_ams_select_tray(std::string tray_id)
 {
     if (!m_agent) return -1;
+    if (!printer_supports_command("print.ams_change_filament")) {
+        BOOST_LOG_TRIVIAL(warning) << "command_ams_select_tray: printer agent does not support the command";
+        return command_with_dialog(ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    }
     return command_with_dialog(m_agent->command_ams_select_tray(get_dev_id(), tray_id, MachineObject::m_sequence_id++, is_lan_mode_printer()));
 }
 
 int MachineObject::command_ams_control(std::string action)
 {
+    if (!printer_supports_command("print.ams_control")) {
+        BOOST_LOG_TRIVIAL(warning) << "command_ams_control: printer agent does not support the command";
+        return command_with_dialog(ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    }
     if (action == "resume" && check_resume_condition()) return 0;
 
     //valid actions
@@ -1868,6 +1951,10 @@ int MachineObject::command_ams_control(std::string action)
 
 int MachineObject::command_ams_drying_stop()
 {
+    if (!printer_supports_command("print.auto_stop_ams_dry")) {
+        BOOST_LOG_TRIVIAL(warning) << "command_ams_drying_stop: printer agent does not support the command";
+        return command_with_dialog(ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    }
     json j;
     j["print"]["command"] = "auto_stop_ams_dry";
     j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
@@ -2818,7 +2905,9 @@ bool MachineObject::is_camera_busy_off()
 int MachineObject::publish_json(const json& json_item, int qos, int flag)
 {
     int rtn = 0;
-    if (is_lan_mode_printer()) {
+    if (m_agent && !m_agent->owns_agent(printer_agent_id)) {
+        rtn = ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED;
+    } else if (is_lan_mode_printer()) {
         rtn = local_publish_json(json_item.dump(), qos, flag);
     } else {
         rtn = cloud_publish_json(json_item.dump(), qos, flag);
@@ -2862,6 +2951,7 @@ int MachineObject::local_publish_json(std::string json_str, int qos, int flag)
 std::string MachineObject::setting_id_to_type(std::string setting_id, std::string tray_type)
 {
     std::string type;
+    if (wxTheApp == nullptr) return tray_type;
     PresetBundle* preset_bundle = GUI::wxGetApp().preset_bundle;
     if (preset_bundle) {
         for (auto it = preset_bundle->filaments.begin(); it != preset_bundle->filaments.end(); it++) {
@@ -4198,6 +4288,9 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                             vt_slot[0].setting_id = jj["tray_info_idx"].get<std::string>();
                             //vt_tray.type = jj["tray_type"].get<std::string>();
                             vt_slot[0].m_fila_type = setting_id_to_type(vt_slot[0].setting_id, jj["tray_type"].get<std::string>());
+                            // The ack carries the whole slot; re-derive empty so the panel flips off
+                            // "Empty" without waiting out the hold.
+                            vt_slot[0].UpdateEmptyState(true);
                             // delay update
                             vt_slot[0].set_hold_count();
                         } else {
@@ -4223,6 +4316,9 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
 
                                     tray_it->second->setting_id = jj["tray_info_idx"].get<std::string>();
                                     tray_it->second->m_fila_type = setting_id_to_type(tray_it->second->setting_id, jj["tray_type"].get<std::string>());
+                                    // The ack carries the whole slot; re-derive empty so the panel flips off
+                                    // "Empty" without waiting out the hold.
+                                    tray_it->second->UpdateEmptyState(true);
                                     // delay update
                                     tray_it->second->set_hold_count();
                                 } else {
@@ -5161,7 +5257,7 @@ DevAmsTray MachineObject::parse_vt_tray(json vtray)
             //std::string type = vtray["tray_type"].get<std::string>();
             std::string type = setting_id_to_type(vt_tray.setting_id, vtray["tray_type"].get<std::string>());
             // vt_tray.setting_id is our OF id (translated on the way in); the two support ids below are the printer's own.
-            auto* agent = GUI::wxGetApp().getAgent();
+            auto* agent = wxTheApp != nullptr ? GUI::wxGetApp().getAgent() : nullptr;
             const std::string printer_filament_id = agent ? agent->from_orca_filament_id(vt_tray.setting_id) : vt_tray.setting_id;
             if (printer_filament_id == "GFS00") {
                 vt_tray.m_fila_type = "PLA-S";
@@ -5256,6 +5352,7 @@ DevAmsTray MachineObject::parse_vt_tray(json vtray)
         else {
             vt_tray.remain = -1;
         }
+        vt_tray.UpdateEmptyState(vtray.contains("tray_info_idx") && vtray.contains("tray_type"));
     }
 
     return vt_tray;
@@ -5549,11 +5646,11 @@ void MachineObject::parse_new_info2(const json& info)
     if (capabilities_it == info.end() || !capabilities_it->is_object())
         return;
     const auto flags_it = capabilities_it->find("flags");
-    if (flags_it == capabilities_it->end() || !flags_it->is_object())
+    const bool has_flags = flags_it != capabilities_it->end() && flags_it->is_object();
+    if (!has_flags)
         return;
-
     const json& flags = *flags_it;
-    BOOST_LOG_TRIVIAL(info) << "parse_new_info2: OrcaSonar capability flags=" << flags.dump();
+    BOOST_LOG_TRIVIAL(info) << "parse_new_info2: capability flags=" << flags.dump();
 
     auto parse_bool = [&flags](const char* name, bool& target) {
         const auto it = flags.find(name);

src/slic3r/GUI/DeviceManager.hpp

@@ -14,6 +14,7 @@
 #include <string>
 #include <memory>
 #include <chrono>
+#include <set>
 #include <unordered_set>
 #include <optional>
 #include <boost/thread.hpp>
@@ -73,6 +74,7 @@ class DeviceErrorDialog; // Previous definitions
 
 class NetworkAgent;
 // Orca: ManualPaCaliMethod now provided by DeviceCore/DevCalib.h (enum class)
+class PresetBundle;
 
 #define UpgradeNoError          0
 #define UpgradeDownloadFailed   -1
@@ -108,6 +110,11 @@ struct DevPrintTaskRatingInfo;
 // given nozzle diameter (mm), bucketed per nozzle size to mirror the printer firmware.
 bool is_stringing_prone_filament(const std::string& filament_id, float nozzle_diameter);
 
+// The printer model filament presets are matched against for a connected machine. OrcaSonar's
+// model id is optional, so a device with no installed vendor model falls back to the selected
+// printer profile rather than resolving to no filament list at all.
+std::string resolve_filament_printer_model(const std::string& printer_type, PresetBundle* preset_bundle);
+
 class MachineObject
 {
 private:
@@ -796,6 +803,13 @@ public:
     int command_refresh_nozzle();
     int command_set_chamber(int temp);
     int check_resume_condition();
+    bool printer_supports_command(const char* command) const;
+    bool printer_supports_feature(const char* feature) const;
+    bool printer_uses_filament_mapping() const;
+    // The per-tray flow-dynamics K/N records are a Bambu firmware feature. Other
+    // agents have no printer-side calibration to read or write, so the AMS UI must
+    // not offer K/N for them.
+    bool supports_extrusion_cali() const;
     // ams controls
     //int command_ams_switch(int tray_index, int old_temp = 210, int new_temp = 210);
     int command_ams_change_filament(bool load, std::string ams_id, std::string slot_id, int old_temp = 210, int new_temp = 210, std::optional<int> extruder_id = std::nullopt);

src/slic3r/GUI/DeviceTab/uiAMSBestPositionPopup.cpp

@@ -970,7 +970,11 @@ int ReselectMachineDialog::CaculateSwitcherDistribution(MachineObject* obj, cons
                 const auto& can = ams.cans[j];
                 auto id = getTrayID(obj, ams.ams_id, can.can_id);
                 auto material = can.material_name;
-                if (can.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND ||
+                if (can.is_empty || can.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY)
+                {
+                    material = L("Empty");
+                }
+                else if (can.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND ||
                     can.material_state == AMSCanType::AMS_CAN_TYPE_BRAND ||
                     can.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL)
                 {
@@ -979,10 +983,6 @@ int ReselectMachineDialog::CaculateSwitcherDistribution(MachineObject* obj, cons
                         material = L("?");
                     }
                 }
-                if (can.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY)
-                {
-                    material = "Empty";
-                }
 
                 auto itOK = std::find_if(posOK.begin(), posOK.end(), [&](const trayHelper& tray){
                     auto amsID = std::get<0>(tray);

src/slic3r/GUI/FilamentMappingUtils.hpp

@@ -0,0 +1,105 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <nlohmann/json.hpp>
+
+#include "libslic3r/ProjectTask.hpp"
+#include "DeviceManager.hpp"
+
+namespace Slic3r {
+namespace GUI {
+
+// True when the normalized ams_mapping2 carries any entry the agent's serializer
+// would put on the wire: every integer pair except the {255,255} unmatched
+// sentinel, external slots ({255,0}/{254,0}) included. This mirrors
+// OrcaPrinterAgent::build_filament_mapping exactly, so the GUI gate and the
+// agent gate agree; a mismatch lets an entry reach the agent and be refused late
+// with a generic publish error instead of the designed message.
+inline bool has_engaged_filament_mapping(const std::string& ams_mapping2)
+{
+    const nlohmann::json mapping = nlohmann::json::parse(ams_mapping2, nullptr, false);
+    if (mapping.is_discarded() || !mapping.is_array())
+        return false;
+    for (const auto& entry : mapping) {
+        if (!entry.is_object())
+            continue;
+        const auto ams_id_it  = entry.find("ams_id");
+        const auto slot_id_it = entry.find("slot_id");
+        if (ams_id_it == entry.end() || slot_id_it == entry.end())
+            continue;
+        if (!ams_id_it->is_number_integer() || !slot_id_it->is_number_integer())
+            continue;
+        if (ams_id_it->get<int>() == 255 && slot_id_it->get<int>() == 255)
+            continue; // unmatched/unused sentinel: the serializer drops it
+        return true;
+    }
+    return false;
+}
+
+// A device with no AMS units has a single source: the external spool. OrcaSlicer's
+// auto-mapping force-selects it for every filament (DevMapping.cpp), but that is not
+// a lane choice: keep it out of the send gate and off print.gcode_file.
+inline void drop_forced_external_selection(bool device_has_ams, std::string& ams_mapping2)
+{
+    if (!device_has_ams)
+        ams_mapping2.clear();
+}
+
+// A used filament with no target would be silently dropped from the wire
+// mapping, so the print must be refused rather than run the wrong material.
+// m_ams_mapping_result carries exactly the filaments the slice uses.
+inline bool has_used_filament_without_target(const std::vector<FilamentInfo>& result)
+{
+    for (const auto& f : result) {
+        if (f.get_ams_id() < 0 || f.get_slot_id() < 0)
+            return true;
+    }
+    return false;
+}
+
+// True when at least one used filament already has a target. The used-unmapped
+// refusal applies to a partially mapped print; a print with no mapping at all
+// is handled by the existing all-invalid send-path flow.
+inline bool has_any_mapped_target(const std::vector<FilamentInfo>& result)
+{
+    for (const auto& f : result) {
+        if (f.get_ams_id() >= 0 && f.get_slot_id() >= 0)
+            return true;
+    }
+    return false;
+}
+
+
+// Refusal reason for a printer agent that serializes lane selection into
+// print.gcode_file's per-print filament_mapping field.
+enum class MappingSendError {
+    none,        // no refusal; ams_mapping2 is normalized for send
+    unsupported, // a mapping is engaged but the connector did not advertise it
+    incomplete,  // a used filament has no target while others do
+};
+
+// Applies the send-time mapping policy and normalizes ams_mapping2 in place.
+// Agents that do not speak filament_mapping keep their legacy payload untouched.
+inline MappingSendError prepare_filament_mapping_for_send(MachineObject* obj,
+                                                          std::string& ams_mapping2,
+                                                          const std::vector<FilamentInfo>& mapping_result)
+{
+    if (!obj || !obj->printer_uses_filament_mapping())
+        return MappingSendError::none;
+
+    // A device with no AMS units has one source, the external spool:
+    // auto-mapping force-selects it, which is not a lane choice. Drop it before
+    // the capability gate so it cannot refuse a print nobody mapped.
+    drop_forced_external_selection(obj->HasAms(), ams_mapping2);
+
+    if (!obj->printer_supports_feature("filament_mapping") && has_engaged_filament_mapping(ams_mapping2))
+        return MappingSendError::unsupported;
+    if (has_any_mapped_target(mapping_result) && has_used_filament_without_target(mapping_result))
+        return MappingSendError::incomplete;
+    return MappingSendError::none;
+}
+
+} // namespace GUI
+} // namespace Slic3r

src/slic3r/GUI/ImageGrid.cpp

@@ -1,5 +1,6 @@
 #include "ImageGrid.h"
 #include "Printer/PrinterFileSystem.h"
+#include "Printer/BambuFileGridModel.h"
 #include "wxExtensions.hpp"
 #include "Widgets/Label.hpp"
 #include "I18N.hpp"
@@ -8,6 +9,7 @@
 
 #include <utility>
 #include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared_object.hpp>
 #include <wx/colour.h>
 #include <cstddef>
 #include <wx/dcclient.h>
@@ -76,18 +78,11 @@ ImageGrid::ImageGrid(wxWindow * parent)
 
 void ImageGrid::SetFileSystem(boost::shared_ptr<PrinterFileSystem> file_sys)
 {
-    if (m_file_sys) {
-        m_file_sys->Unbind(EVT_MODE_CHANGED, &ImageGrid::changedEvent, this);
-        m_file_sys->Unbind(EVT_FILE_CHANGED, &ImageGrid::changedEvent, this);
-        m_file_sys->Unbind(EVT_THUMBNAIL, &ImageGrid::changedEvent, this);
-        m_file_sys->Unbind(EVT_DOWNLOAD, &ImageGrid::changedEvent, this);
-    }
     m_file_sys = file_sys;
-    if (m_file_sys) {
-        m_file_sys->Bind(EVT_MODE_CHANGED, &ImageGrid::changedEvent, this);
-        m_file_sys->Bind(EVT_FILE_CHANGED, &ImageGrid::changedEvent, this);
-        m_file_sys->Bind(EVT_THUMBNAIL, &ImageGrid::changedEvent, this);
-        m_file_sys->Bind(EVT_DOWNLOAD, &ImageGrid::changedEvent, this);
+    m_model.reset();
+    if (file_sys) {
+        m_model = boost::make_shared<BambuFileGridModel>(file_sys);
+        m_model->SetChangeHandler([this](FileGridChange c) { onModelChange(c); });
     }
     m_row_count = 0;
     m_col_count = 1;
@@ -96,9 +91,22 @@ void ImageGrid::SetFileSystem(boost::shared_ptr<PrinterFileSystem> file_sys)
     UpdateFileSystem();
 }
 
+void ImageGrid::SetModel(boost::shared_ptr<IFileGridModel> model)
+{
+    m_file_sys.reset();
+    m_model = std::move(model);
+    if (m_model)
+        m_model->SetChangeHandler([this](FileGridChange c) { onModelChange(c); });
+    m_row_count = 0;
+    m_col_count = 1;
+    m_row_offset = 0;
+    m_scroll_offset = 0;
+    UpdateFileSystem();
+}
+
 void ImageGrid::SetStatus(ScalableBitmap const & icon, wxString const &msg)
 {
-    int code     = m_file_sys ? m_file_sys->GetLastError() : 1;
+    int code     = m_model ? m_model->GetLastError() : 1;
     m_status_icon = icon;
     m_status_msg = wxString::Format(msg, code);
     BOOST_LOG_TRIVIAL(info) << "ImageGrid::SetStatus: " << m_status_msg.ToUTF8().data();
@@ -107,26 +115,26 @@ void ImageGrid::SetStatus(ScalableBitmap const & icon, wxString const &msg)
 
 void Slic3r::GUI::ImageGrid::SetFileType(int type, std::string const &storage)
 {
-    if (!m_file_sys)
+    if (!m_model)
         return;
-    m_file_sys->SetFileType((PrinterFileSystem::FileType) type, storage);
+    m_model->SetFileType((FileGridType) type, storage);
 }
 
 void Slic3r::GUI::ImageGrid::SetGroupMode(int mode)
 {
-    if (!m_file_sys)
+    if (!m_model)
         return;
-    if (m_file_sys->GetCount() == 0) {
-        m_file_sys->SetGroupMode((PrinterFileSystem::GroupMode) mode);
+    if (m_model->GetCount() == 0) {
+        m_model->SetGroupMode((FileGridGroup) mode);
         return;
     }
     wxSize size = GetClientSize();
     int index = (m_row_offset + 1 < m_row_count || m_row_count == 0) 
         ? m_row_offset / 4 * m_col_count 
-        : ((m_file_sys->GetCount() + m_col_count - 1) / m_col_count - (size.y + m_border_size.GetHeight() - 1) / m_cell_size.GetHeight()) * m_col_count;
-    auto & file = m_file_sys->GetFile(index);
-    m_file_sys->SetGroupMode((PrinterFileSystem::GroupMode) mode);
-    index = m_file_sys->GetIndexAtTime(file.time);
+        : ((m_model->GetCount() + m_col_count - 1) / m_col_count - (size.y + m_border_size.GetHeight() - 1) / m_cell_size.GetHeight()) * m_col_count;
+    time_t time = m_model->GetFile(index).time;
+    m_model->SetGroupMode((FileGridGroup) mode);
+    index = m_model->GetIndexAtTime(time);
     // UpdateFileSystem(); call by changed event
     m_row_offset = index / m_col_count * 4;
     if (m_row_offset >= m_row_count)
@@ -137,8 +145,8 @@ void Slic3r::GUI::ImageGrid::SetGroupMode(int mode)
 void Slic3r::GUI::ImageGrid::SetSelecting(bool selecting)
 {
     m_selecting = selecting;
-    if (m_file_sys)
-        m_file_sys->SelectAll(false);
+    if (m_model)
+        m_model->SelectAll(false);
     Refresh();
 }
 
@@ -166,14 +174,14 @@ void Slic3r::GUI::ImageGrid::Rescale()
 void Slic3r::GUI::ImageGrid::Select(size_t index)
 {
     if (m_selecting) {
-        m_file_sys->ToggleSelect(index);
+        m_model->ToggleSelect(index);
         Refresh();
         return;
     }
-    if (m_file_sys->GetGroupMode() == PrinterFileSystem::G_NONE) {
+    if (m_model->GetGroupMode() == FileGridGroup::All) {
         return;
     }
-    index = m_file_sys->EnterSubGroup(index);
+    index = m_model->EnterSubGroup(index);
     // UpdateFileSystem(); call by changed event
     m_row_offset = index / m_col_count * 4;
     if (m_row_offset >= m_row_count)
@@ -193,9 +201,9 @@ void Slic3r::GUI::ImageGrid::DoAction(size_t index, int action)
 
 void Slic3r::GUI::ImageGrid::UpdateFileSystem()
 {
-    if (!m_file_sys) return;
-    if (m_file_sys->GetFileType() < PrinterFileSystem::F_MODEL) {
-        if (m_file_sys->GetGroupMode() == PrinterFileSystem::G_NONE) {
+    if (!m_model) return;
+    if (m_model->GetFileType() < FileGridType::Model) {
+        if (m_model->GetGroupMode() == FileGridGroup::All) {
             m_cell_size.Set(396, 228);
             m_border_size.Set(384, 216);
         }
@@ -216,10 +224,10 @@ void Slic3r::GUI::ImageGrid::UpdateFileSystem()
 
 void ImageGrid::UpdateLayout()
 {
-    if (!m_file_sys) return;
+    if (!m_model) return;
     wxSize size = GetClientSize();
     wxSize title_mask_size{0, 60 * em_unit(this) / 10};
-    if (m_file_sys->GetGroupMode() == PrinterFileSystem::G_NONE) {
+    if (m_model->GetGroupMode() == FileGridGroup::All) {
         title_mask_size.y = 20 * em_unit(this) / 10;
         size.y -= title_mask_size.y;
     }
@@ -227,7 +235,7 @@ void ImageGrid::UpdateLayout()
     int cell_height = m_cell_size.GetHeight();
     int ncol = (size.GetWidth() - cell_width + m_border_size.GetWidth()) / cell_width;
     if (ncol <= 0) ncol = 1;
-    int total_height = (m_file_sys->GetCount() + ncol - 1) / ncol * cell_height + cell_height - m_border_size.GetHeight();
+    int total_height = (m_model->GetCount() + ncol - 1) / ncol * cell_height + cell_height - m_border_size.GetHeight();
     int nrow = (total_height - size.GetHeight() + cell_height / 4 - 1) / (cell_height / 4);
     m_row_offset = m_row_offset * m_col_count / ncol;
     m_col_count = ncol;
@@ -236,7 +244,7 @@ void ImageGrid::UpdateLayout()
         m_row_offset = m_row_count == 0 ? 0 : m_row_count - 1;
     m_scroll_offset = 0;
     // create mask
-    if (m_file_sys->GetGroupMode() == PrinterFileSystem::G_NONE) {
+    if (m_model->GetGroupMode() == FileGridGroup::All) {
         title_mask_size.x = (m_col_count - 1) * m_cell_size.GetWidth() + m_border_size.GetWidth();
     }
     else {
@@ -252,7 +260,7 @@ void ImageGrid::UpdateLayout()
 
 void Slic3r::GUI::ImageGrid::UpdateFocusRange()
 {
-    if (!m_file_sys) return;
+    if (!m_model) return;
     wxSize  size = GetClientSize();
     wxPoint off;
     int     index = firstItem(size, off);
@@ -261,15 +269,21 @@ void Slic3r::GUI::ImageGrid::UpdateFocusRange()
         count += m_col_count;
         off.y += m_cell_size.y;
     }
-    m_file_sys->SetFocusRange(index, count);
+    m_model->SetFocusRange(index, count);
+}
+
+bool Slic3r::GUI::ImageGrid::hasSecondAction(const FileGridCard &card) const
+{
+    return m_show_download || card.downloading ||
+           (m_model->GetFileType() == FileGridType::Model && card.printable);
 }
 
 std::pair<int, size_t> Slic3r::GUI::ImageGrid::HitTest(wxPoint const &pt)
 {
-    if (!m_file_sys)
+    if (!m_model)
         return {HIT_NONE, -1};
     wxSize size  = GetClientSize();
-    if (m_file_sys->GetCount() == 0) {
+    if (m_model->GetCount() == 0) {
         if (wxRect({0, 0}, m_border_size).CenterIn(wxRect({0, 0}, size)).Contains(pt))
             return {HIT_STATUS, 0};
         return {HIT_NONE, -1};
@@ -287,17 +301,19 @@ std::pair<int, size_t> Slic3r::GUI::ImageGrid::HitTest(wxPoint const &pt)
         index += m_col_count;
         off.y -= m_cell_size.GetHeight();
     }
-    if (index >= m_file_sys->GetCount()) { return {HIT_NONE, -1}; }
+    if (index >= m_model->GetCount()) { return {HIT_NONE, -1}; }
     if (!m_content_rect.Contains(off)) { return {HIT_NONE, -1}; }
     if (!m_selecting) {
         wxRect hover_rect{0, m_content_rect.GetHeight() - m_buttons_background.GetHeight(), m_content_rect.GetWidth(), m_buttons_background.GetHeight()};
-        auto & file = m_file_sys->GetFile(index);
-        int    btn  = file.IsDownload() && file.DownloadProgress() >= 0 ? 3 : 2;
-        if (m_file_sys->GetFileType() == PrinterFileSystem::F_MODEL) {
-            if (m_show_download)
+        const FileGridCard &card = m_model->GetFile(index);
+        int    btn  = card.downloading && card.download_progress >= 0 ? 3 : 2;
+        if (m_model->GetFileType() == FileGridType::Model) {
+            if (m_show_download && card.printable)
                 btn = 3;
             hover_rect.y -= m_content_rect.GetHeight() * 64 / 264;
         }
+        if (!hasSecondAction(card))
+            btn = 1;
         if (hover_rect.Contains(off.x, off.y)) {
             return {HIT_ACTION, index * 4 + off.x * btn / hover_rect.GetWidth()};
         } // Two buttons
@@ -315,12 +331,12 @@ void ImageGrid::mouseMoved(wxMouseEvent& event)
         m_hit_item = hit.second;
         if (hit.first == HIT_ITEM) {
             SetToolTip({});
-            auto & file = m_file_sys->GetFile(hit.second);
-            if (auto title = file.Title(); !title.empty()) {
-                auto tip = wxString::Format(_L("File: %s\nTitle: %s\n"), from_u8(file.name), from_u8(title));
+            const FileGridCard &card = m_model->GetFile(hit.second);
+            if (auto title = card.title; !title.empty()) {
+                auto tip = wxString::Format(_L("File: %s\nTitle: %s\n"), from_u8(card.name), from_u8(title));
                 SetToolTip(tip);
             } else {
-                SetToolTip(from_u8(file.name));
+                SetToolTip(from_u8(card.name));
             }
         } else
             SetToolTip({});
@@ -372,9 +388,9 @@ void ImageGrid::mouseReleased(wxMouseEvent& event)
         else if (m_hit_type == HIT_ACTION)
             DoAction(m_hit_item / 4, m_hit_item & 3);
         else if (m_hit_type == HIT_MODE)
-            SetGroupMode(static_cast<PrinterFileSystem::GroupMode>(2 - m_hit_item));
+            SetGroupMode(static_cast<int>(2 - m_hit_item));
         else if (m_hit_type == HIT_STATUS)
-            m_file_sys->Retry();
+            m_model->Retry();
         else
             Refresh();
     } else {
@@ -403,20 +419,11 @@ void ImageGrid::mouseWheelMoved(wxMouseEvent &event)
     Refresh();
 }
 
-void Slic3r::GUI::ImageGrid::changedEvent(wxCommandEvent& evt)
+void Slic3r::GUI::ImageGrid::onModelChange(FileGridChange change)
 {
-    evt.Skip();
-    BOOST_LOG_TRIVIAL(debug) << "ImageGrid::changedEvent: " << evt.GetEventType() << " index: " << evt.GetInt() 
-            << " name: " << evt.GetString().ToUTF8().data() << " extra: " << evt.GetExtraLong();
-    if (evt.GetEventType() == EVT_FILE_CHANGED) {
-        if (evt.GetInt() == -1)
-            m_file_sys->DownloadCheckFiles(wxGetApp().app_config->get("download_path"));
+    BOOST_LOG_TRIVIAL(debug) << "ImageGrid::onModelChange: " << (int) change;
+    if (change == FileGridChange::Files || change == FileGridChange::Mode)
         UpdateFileSystem();
-    }
-    else if (evt.GetEventType() == EVT_MODE_CHANGED)
-        UpdateFileSystem();
-    //else if (evt.GetEventType() == EVT_THUMBNAIL)
-    //    RefreshRect(itemRect(evt.GetInt()), false);
     else
         Refresh();
 }
@@ -431,7 +438,7 @@ void ImageGrid::paintEvent(wxPaintEvent& evt)
 size_t Slic3r::GUI::ImageGrid::firstItem(wxSize const &size, wxPoint &off)
 {
     int size_y = size.y;
-    if (m_file_sys->GetGroupMode() == PrinterFileSystem::G_NONE)
+    if (m_model->GetGroupMode() == FileGridGroup::All)
         size_y -= m_title_mask.GetHeight();
     int offx  = (size.x - (m_col_count - 1) * m_cell_size.GetWidth() - m_border_size.GetWidth()) / 2;
     int offy  = (m_row_offset + 1 < m_row_count || m_row_count == 0) ?
@@ -439,8 +446,8 @@ size_t Slic3r::GUI::ImageGrid::firstItem(wxSize const &size, wxPoint &off)
                     size_y - (size_y + m_border_size.GetHeight() - 1) / m_cell_size.GetHeight() * m_cell_size.GetHeight();
     int index = (m_row_offset + 1 < m_row_count || m_row_count == 0) ?
                     m_row_offset / 4 * m_col_count :
-                    ((m_file_sys->GetCount() + m_col_count - 1) / m_col_count - (size_y + m_border_size.GetHeight() - 1) / m_cell_size.GetHeight()) * m_col_count;
-    if (m_file_sys->GetGroupMode() == PrinterFileSystem::G_NONE)
+                    ((m_model->GetCount() + m_col_count - 1) / m_col_count - (size_y + m_border_size.GetHeight() - 1) / m_cell_size.GetHeight()) * m_col_count;
+    if (m_model->GetGroupMode() == FileGridGroup::All)
         offy += m_title_mask.GetHeight();
     off = wxPoint{offx, offy};
     return index;
@@ -534,7 +541,7 @@ void ImageGrid::render(wxDC& dc)
     wxSize size = GetClientSize();
     dc.SetPen(wxPen(GetBackgroundColour()));
     dc.SetBrush(wxBrush(GetBackgroundColour()));
-    if (!m_file_sys || m_file_sys->GetCount() == 0) {
+    if (!m_model || m_model->GetCount() == 0) {
         dc.DrawRectangle({ 0, 0, size.x, size.y });
         if (!m_status_msg.IsEmpty()) {
             auto   si = m_status_icon.GetBmpSize();
@@ -562,7 +569,7 @@ void ImageGrid::render(wxDC& dc)
     {
         // Draw one line
         wxPoint pt{off.x, off.y};
-        end = (index + m_col_count) < m_file_sys->GetCount() ? index + m_col_count : m_file_sys->GetCount();
+        end = (index + m_col_count) < m_model->GetCount() ? index + m_col_count : m_model->GetCount();
         while (index < end) {
             pt += m_content_rect.GetTopLeft();
             // Draw content
@@ -571,7 +578,7 @@ void ImageGrid::render(wxDC& dc)
                 &ImageGrid::renderContent1,
                 &ImageGrid::renderContent2
             };
-            (this->*contentRender[m_file_sys->GetFileType()])(dc, pt, index, hit_image == index);
+            (this->*contentRender[static_cast<int>(m_model->GetFileType())])(dc, pt, index, hit_image == index);
             pt -= m_content_rect.GetTopLeft();
             // Draw colume spacing at right
             dc.DrawRectangle({pt.x + m_border_size.GetWidth(), pt.y, m_cell_size.GetWidth() - m_border_size.GetWidth(), m_border_size.GetHeight()});
@@ -588,13 +595,13 @@ void ImageGrid::render(wxDC& dc)
         off.y += m_cell_size.GetHeight();
     }
     // Draw floating date range for non-group list
-    if (m_file_sys->GetGroupMode() == PrinterFileSystem::G_NONE && m_file_sys->GetCount() > 0) {
+    if (m_model->GetGroupMode() == FileGridGroup::All && m_model->GetCount() > 0) {
         //dc.DrawBitmap(m_title_mask, {off.x, 0});
         dc.DrawRectangle({off.x, 0}, m_title_mask.GetSize());
-        auto & file1 = m_file_sys->GetFile(start);
-        auto & file2 = m_file_sys->GetFile(end - 1);
-        auto date1 = wxDateTime((time_t) file1.time).Format(_L(TIME_FORMATS[m_file_sys->GetGroupMode()]));
-        auto date2 = wxDateTime((time_t) file2.time).Format(_L(TIME_FORMATS[m_file_sys->GetGroupMode()]));
+        const FileGridCard & file1 = m_model->GetFile(start);
+        const FileGridCard & file2 = m_model->GetFile(end - 1);
+        auto date1 = wxDateTime((time_t) file1.time).Format(_L(TIME_FORMATS[static_cast<int>(m_model->GetGroupMode())]));
+        auto date2 = wxDateTime((time_t) file2.time).Format(_L(TIME_FORMATS[static_cast<int>(m_model->GetGroupMode())]));
         dc.SetFont(Label::Head_16);
         dc.SetTextForeground(StateColor::darkModeColorFor("#262E30"));
         dc.DrawText(date1 + " - " + date2, wxPoint{off.x, 2});
@@ -604,7 +611,7 @@ void ImageGrid::render(wxDC& dc)
         dc.DrawRectangle({off.x, off.y, size.x - off.x * 2, size.y - off.y});
     // Draw position bar
     if (m_timer.IsRunning()) {
-        int total_height = (m_file_sys->GetCount() + m_col_count - 1) / m_col_count * m_cell_size.GetHeight() + m_cell_size.GetHeight() - m_border_size.GetHeight();
+        int total_height = (m_model->GetCount() + m_col_count - 1) / m_col_count * m_cell_size.GetHeight() + m_cell_size.GetHeight() - m_border_size.GetHeight();
         if (total_height > size.y) {
             int offset = (m_row_offset + 1 < m_row_count || m_row_count == 0) ? m_row_offset * (m_cell_size.GetHeight() / 4) : total_height - size.y;
             wxRect rect = {size.x - 16, offset * size.y / total_height, 8,
@@ -618,15 +625,35 @@ void ImageGrid::render(wxDC& dc)
 void Slic3r::GUI::ImageGrid::renderContent1(wxDC &dc, wxPoint const &pt, int index, bool hit)
 {
     bool selected = false;
-    auto &file = m_file_sys->GetFile(index, selected);
+    const FileGridCard &card = m_model->GetFile(index, selected);
     // Draw thumbnail
-    if (file.thumbnail.IsOk()) {
-        float hs = (float) m_content_rect.GetWidth() / file.thumbnail.GetWidth();
-        float vs = (float) m_content_rect.GetHeight() / file.thumbnail.GetHeight();
-        dc.SetUserScale(hs, vs);
-        dc.DrawBitmap(file.thumbnail, {(int) (pt.x / hs), (int) (pt.y / vs)});
-        dc.SetUserScale(1, 1);
-        if (m_file_sys->GetGroupMode() != PrinterFileSystem::G_NONE) { dc.DrawBitmap(m_title_mask, pt); }
+    if (card.thumbnail.IsOk()) {
+        if (m_model->preserve_thumbnail_aspect()) {
+            // Contain: fit the whole thumbnail and letterbox against the tile background.
+            float scale = std::min((float) m_content_rect.GetWidth() / card.thumbnail.GetWidth(),
+                                   (float) m_content_rect.GetHeight() / card.thumbnail.GetHeight());
+            int   thumb_w = (int) (card.thumbnail.GetWidth() * scale);
+            int   thumb_h = (int) (card.thumbnail.GetHeight() * scale);
+            int   offx    = (m_content_rect.GetWidth() - thumb_w) / 2;
+            int   offy    = (m_content_rect.GetHeight() - thumb_h) / 2;
+            auto  brush   = dc.GetBrush();
+            auto  pen     = dc.GetPen();
+            dc.SetBrush(StateColor::darkModeColorFor(0xEEEEEE));
+            dc.SetPen(StateColor::darkModeColorFor(0xEEEEEE));
+            dc.DrawRectangle(pt, m_content_rect.GetSize());
+            dc.SetUserScale(scale, scale);
+            dc.DrawBitmap(card.thumbnail, {(int) ((pt.x + offx) / scale), (int) ((pt.y + offy) / scale)});
+            dc.SetUserScale(1, 1);
+            dc.SetBrush(brush);
+            dc.SetPen(pen);
+        } else {
+            float hs = (float) m_content_rect.GetWidth() / card.thumbnail.GetWidth();
+            float vs = (float) m_content_rect.GetHeight() / card.thumbnail.GetHeight();
+            dc.SetUserScale(hs, vs);
+            dc.DrawBitmap(card.thumbnail, {(int) (pt.x / hs), (int) (pt.y / vs)});
+            dc.SetUserScale(1, 1);
+        }
+        if (m_model->GetGroupMode() != FileGridGroup::All) { dc.DrawBitmap(m_title_mask, pt); }
     }
     bool show_download_state_always = true;
     // Draw checked icon
@@ -634,14 +661,14 @@ void Slic3r::GUI::ImageGrid::renderContent1(wxDC &dc, wxPoint const &pt, int ind
         dc.DrawBitmap(selected ? m_checked_icon.bmp() : m_unchecked_icon.bmp(), pt + wxPoint{10, 10});
     // can't handle alpha
     // dc.GradientFillLinear({pt.x, pt.y, m_border_size.GetWidth(), 60}, wxColour(0x6F, 0x6F, 0x6F, 0x99), wxColour(0x6F, 0x6F, 0x6F, 0), wxBOTTOM);
-    else if (m_file_sys->GetGroupMode() == PrinterFileSystem::G_NONE) {
+    else if (m_model->GetGroupMode() == FileGridGroup::All) {
         wxString nonHoverText;
         wxString secondAction = m_show_download ? _L("Download") : "";
         wxString thirdAction;
         int      states = 0;
         // Draw download progress
-        if (file.IsDownload()) {
-            int progress = file.DownloadProgress();
+        if (card.downloading) {
+            int progress = card.download_progress;
             if (progress == -1) {
                 secondAction = _L("Cancel");
                 nonHoverText = _L("Download waiting...");
@@ -659,7 +686,7 @@ void Slic3r::GUI::ImageGrid::renderContent1(wxDC &dc, wxPoint const &pt, int ind
                 thirdAction  = wxString::Format(L"%d%%...", progress);
             }
         }
-        if (m_file_sys->GetFileType() == PrinterFileSystem::F_MODEL) {
+        if (m_model->GetFileType() == FileGridType::Model && card.printable) {
             if (secondAction != _L("Play"))
                 thirdAction = secondAction;
             secondAction = _L_CONTEXT("Print", "Verb");
@@ -669,7 +696,8 @@ void Slic3r::GUI::ImageGrid::renderContent1(wxDC &dc, wxPoint const &pt, int ind
         wxArrayString texts;
         if (hit) {
             texts.Add(_L("Delete"));
-            texts.Add(secondAction);
+            if (hasSecondAction(card))
+                texts.Add(secondAction);
             if (!thirdAction.IsEmpty())
                 texts.Add(thirdAction);
             renderButtons(dc, texts, rect, m_hit_type == HIT_ACTION ? m_hit_item & 3 : -1, states);
@@ -679,7 +707,7 @@ void Slic3r::GUI::ImageGrid::renderContent1(wxDC &dc, wxPoint const &pt, int ind
         }
     } else {
         dc.SetTextForeground(*wxWHITE); // time text color
-        auto date = wxDateTime((time_t) file.time).Format(_L(TIME_FORMATS[m_file_sys->GetGroupMode()]));
+        auto date = wxDateTime((time_t) card.time).Format(_L(TIME_FORMATS[static_cast<int>(m_model->GetGroupMode())]));
         dc.DrawText(date, pt + wxPoint{24, 16});
     }
     if (m_selecting && show_download_state_always)
@@ -688,7 +716,7 @@ void Slic3r::GUI::ImageGrid::renderContent1(wxDC &dc, wxPoint const &pt, int ind
 
 void Slic3r::GUI::ImageGrid::renderContent2(wxDC &dc, wxPoint const &pt, int index, bool hit)
 {
-    auto &file = m_file_sys->GetFile(index);
+    const FileGridCard &card = m_model->GetFile(index);
     // Draw thumbnail & buttons
     int h = m_content_rect.GetHeight() * 64 / 264;
     m_content_rect.SetHeight(m_content_rect.GetHeight() - h);
@@ -711,14 +739,14 @@ void Slic3r::GUI::ImageGrid::renderContent2(wxDC &dc, wxPoint const &pt, int ind
     auto em = em_unit(this);
     wxRect rect{pt.x, pt.y + m_content_rect.GetHeight() - h, m_content_rect.GetWidth(), h / 2};
     rect.Deflate(em, 0);
-    renderText2(dc, from_u8(file.name), rect);
+    renderText2(dc, from_u8(card.name), rect);
     rect.Offset(0, h / 2);
     rect.SetWidth(rect.GetWidth() / 2 - em);
     dc.SetFont(Label::Body_13);
     dc.SetTextForeground(StateColor::darkModeColorFor("#6B6B6B"));
-    renderIconText(dc, m_model_time_icon, file.Metadata("Time", "0m"), rect);
+    renderIconText(dc, m_model_time_icon, card.time_text.empty() ? wxString("0m") : from_u8(card.time_text), rect);
     rect.Offset(m_content_rect.GetWidth() / 2, 0);
-    renderIconText(dc, m_model_weight_icon, file.Metadata("Weight", "0g"), rect);
+    renderIconText(dc, m_model_weight_icon, card.weight_text.empty() ? wxString("0g") : from_u8(card.weight_text), rect);
 }
 
 void Slic3r::GUI::ImageGrid::renderButtons(wxDC &dc, wxArrayString const &texts, wxRect const &rect2, size_t hit, int states)

src/slic3r/GUI/ImageGrid.h

@@ -23,6 +23,7 @@
 
 #include "Widgets/StateColor.hpp"
 #include "wxExtensions.hpp"
+#include "Printer/IFileGridModel.h"
 
 class Button;
 class Label;
@@ -44,6 +45,8 @@ public:
 
     void SetFileSystem(boost::shared_ptr<PrinterFileSystem> file_sys);
 
+    void SetModel(boost::shared_ptr<IFileGridModel> model);
+
     void SetStatus(ScalableBitmap const & icon, wxString const &msg);
 
     boost::shared_ptr<PrinterFileSystem> GetFileSystem() { return m_file_sys; }
@@ -76,9 +79,12 @@ protected:
 
     std::pair<int, size_t> HitTest(wxPoint const &pt);
 
+    // True when the hover bar shows a second action next to Delete.
+    bool hasSecondAction(const FileGridCard &card) const;
+
 protected:
 
-    void changedEvent(wxCommandEvent& evt);
+    void onModelChange(FileGridChange change);
 
     void paintEvent(wxPaintEvent& evt);
 
@@ -117,6 +123,7 @@ protected:
 
 private:
     boost::shared_ptr<PrinterFileSystem> m_file_sys;
+    boost::shared_ptr<IFileGridModel>     m_model;
     ScalableBitmap m_status_icon;
     wxString m_status_msg;
 

src/slic3r/GUI/MediaFilePanel.cpp

@@ -230,7 +230,13 @@ MediaFilePanel::MediaFilePanel(wxWindow * parent)
         });
     };
     Bind(wxEVT_SHOW, onShowHide);
-    parent->GetParent()->Bind(wxEVT_SHOW, onShowHide);
+    // Watch the page host's show/hide. Walk up past any wrapper containers (e.g. a
+    // StoragePanel) so the target stays the same regardless of nesting depth.
+    wxWindow* host = parent;
+    while (host && !host->IsTopLevel() && host->GetParent() && !host->GetParent()->IsTopLevel())
+        host = host->GetParent();
+    if (host && host != this)
+        host->Bind(wxEVT_SHOW, onShowHide);
 
     m_lan_user = "bblp";
 }

src/slic3r/GUI/Monitor.cpp

@@ -16,7 +16,6 @@
 #include "slic3r/GUI/StatusPanel.hpp"
 #include "slic3r/GUI/UpgradePanel.hpp"
 #include "slic3r/GUI/Widgets/SideTools.hpp"
-#include "slic3r/GUI/Printer/PrinterFileSystem.h"
 #include <wx/app.h>
 #include <wx/bookctrl.h>
 #include <wx/button.h>
@@ -47,7 +46,7 @@
 #include "Widgets/Label.hpp"
 #include "format.hpp"
 #include "MediaPlayCtrl.h"
-#include "MediaFilePanel.h"
+#include "StoragePanel.h"
 #include "Plater.hpp"
 #include "BindDialog.hpp"
 
@@ -198,9 +197,9 @@ void MonitorPanel::init_tabpanel()
     m_tabpanel->SetBackgroundColour(wxColour("#FEFFFF"));
     m_tabpanel->Bind(wxEVT_BOOKCTRL_PAGE_CHANGED, [this](wxBookCtrlEvent& e) {
         auto page = m_tabpanel->GetCurrentPage();
-        if (page == m_media_file_panel) {
+        if (page == m_storage_panel) {
             auto title = m_tabpanel->GetPageText(m_tabpanel->GetSelection());
-            m_media_file_panel->SwitchStorage(title == _L("Storage"));
+            m_storage_panel->SwitchStorage(title == _L("Storage"));
         }
         // The first page is selected while the panel is built off screen.
         if (page->IsShownOnScreen())
@@ -214,8 +213,8 @@ void MonitorPanel::init_tabpanel()
     add_build_steps_of(*m_status_info_panel);
     m_tabpanel->AddPage(m_status_info_panel, _L("Status"), true);
     add_build_step([this] {
-        m_media_file_panel = new MediaFilePanel(m_tabpanel);
-        m_tabpanel->AddPage(m_media_file_panel, _L("Storage"), false);
+        m_storage_panel = new StoragePanel(m_tabpanel);
+        m_tabpanel->AddPage(m_storage_panel, _L("Storage"), false);
     });
     add_build_step([this] {
         m_upgrade_panel = new UpgradePanel(m_tabpanel);
@@ -264,7 +263,8 @@ void MonitorPanel::on_sys_color_changed()
 {
     m_status_info_panel->on_sys_color_changed();
     m_upgrade_panel->on_sys_color_changed();
-    m_media_file_panel->Rescale();
+    m_storage_panel->on_sys_color_changed();
+    m_storage_panel->Rescale();
 }
 
 void MonitorPanel::msw_rescale()
@@ -276,7 +276,7 @@ void MonitorPanel::msw_rescale()
     m_tabpanel->Rescale();
     //m_status_add_machine_panel->msw_rescale();
     m_status_info_panel->msw_rescale();
-    m_media_file_panel->Rescale();
+    m_storage_panel->Rescale();
     m_upgrade_panel->msw_rescale();
     m_hms_panel->msw_rescale();
 
@@ -423,8 +423,8 @@ void MonitorPanel::update_all()
         }
     } else if (current_page == m_upgrade_panel) {
         m_upgrade_panel->update(obj);
-    } else if (current_page == m_media_file_panel) {
-        m_media_file_panel->UpdateByObj(obj);
+    } else if (current_page == m_storage_panel) {
+        m_storage_panel->UpdateByObj(obj);
     }
 
     if (current_page == m_hms_panel || (obj->GetHMS()->GetHMSItems().size() != m_hms_panel->temp_hms_list.size())) {

src/slic3r/GUI/Monitor.hpp

@@ -60,7 +60,7 @@
 namespace Slic3r {
 namespace GUI {
 
-class MediaFilePanel;
+class StoragePanel;
 
 class AddMachinePanel : public wxPanel
 {
@@ -86,7 +86,7 @@ private:
     wxSizer*        m_main_sizer{ nullptr };
 
     StatusPanel*        m_status_info_panel{ nullptr };
-    MediaFilePanel*     m_media_file_panel{ nullptr };
+    StoragePanel*       m_storage_panel{ nullptr };
     UpgradePanel*       m_upgrade_panel{ nullptr };
     HMSPanel*           m_hms_panel{ nullptr };
 

src/slic3r/GUI/OrcaFilesPanel.cpp

@@ -0,0 +1,268 @@
+#include "OrcaFilesPanel.h"
+
+#include "DeviceManager.hpp"
+#include "GUI_App.hpp"
+#include "GUI.hpp"
+#include "I18N.hpp"
+#include "ImageGrid.h"
+#include "MsgDialog.hpp"
+#include "Widgets/Button.hpp"
+#include "Widgets/Label.hpp"
+#include "Widgets/StaticBox.hpp"
+#include "Widgets/StateColor.hpp"
+#include "slic3r/Utils/NetworkAgent.hpp"
+#include "slic3r/Utils/bambu_networking.hpp"
+
+#include <boost/make_shared.hpp>
+#include <wx/colour.h>
+#include <wx/sizer.h>
+#include <utility>
+
+namespace Slic3r {
+namespace GUI {
+
+OrcaFilesPanel::OrcaFilesPanel(wxWindow* parent)
+    : wxPanel(parent, wxID_ANY)
+    , m_bmp_loading(this, "media_loading", 0)
+    , m_bmp_failed(this, "media_failed", 0)
+    , m_bmp_empty(this, "media_empty", 0)
+{
+    const wxColour light_background("#EEEEEE");
+    SetBackgroundColour(wxGetApp().dark_mode() ? StateColor::darkModeColorFor(light_background) : light_background);
+
+    auto* sizer = new wxBoxSizer(wxVERTICAL);
+    auto* toolbar = new wxBoxSizer(wxHORIZONTAL);
+    toolbar->SetMinSize({-1, 75 * em_unit(this) / 10});
+
+    m_root_label = new Label(this, _L("gcodes"));
+    m_root_label->SetFont(Label::Head_16);
+    toolbar->Add(m_root_label, 0, wxALIGN_CENTER_VERTICAL | wxLEFT, 24);
+
+    m_time_panel = new ::StaticBox(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBORDER_NONE);
+    m_time_panel->SetCornerRadius(0);
+    m_button_year = new ::Button(m_time_panel, _L("Year"), "", wxBORDER_NONE);
+    m_button_month = new ::Button(m_time_panel, _L("Month"), "", wxBORDER_NONE);
+    m_button_all = new ::Button(m_time_panel, _L("All Files"), "", wxBORDER_NONE);
+    m_button_year->SetToolTip(_L("Group files by year, recent first."));
+    m_button_month->SetToolTip(_L("Group files by month, recent first."));
+    m_button_all->SetToolTip(_L("Show all files, recent first."));
+    for (auto* button : {m_button_year, m_button_month, m_button_all}) {
+        button->SetBackgroundColor(StateColor(
+            std::make_pair(0xEEEEEE, static_cast<int>(StateColor::Checked)),
+            std::make_pair(*wxLIGHT_GREY, static_cast<int>(StateColor::Hovered)),
+            std::make_pair(*wxWHITE, static_cast<int>(StateColor::Normal))));
+        button->SetTextColor(StateColor(
+            std::make_pair(0x3B4446, static_cast<int>(StateColor::Checked)),
+            std::make_pair(*wxLIGHT_GREY, static_cast<int>(StateColor::Hovered)),
+            std::make_pair(0xABACAC, static_cast<int>(StateColor::Normal))));
+        button->SetCanFocus(false);
+    }
+    auto* time_sizer = new wxBoxSizer(wxHORIZONTAL);
+    time_sizer->Add(m_button_year, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, 24);
+    time_sizer->Add(m_button_month, 0, wxALIGN_CENTER_VERTICAL);
+    time_sizer->Add(m_button_all, 0, wxALIGN_CENTER_VERTICAL | wxLEFT | wxRIGHT, 24);
+    m_time_panel->SetSizer(time_sizer);
+    toolbar->AddStretchSpacer(1);
+    toolbar->Add(m_time_panel, 0, wxALIGN_CENTER_VERTICAL);
+    toolbar->AddStretchSpacer(1);
+
+    m_button_refresh = new ::Button(this, _L("Refresh"));
+    m_button_refresh->SetToolTip(_L("Reload file list from printer."));
+    m_button_refresh->SetFont(Label::Body_12);
+    m_button_refresh->SetCornerRadius(12);
+    m_button_refresh->SetPaddingSize({10, 6});
+    m_button_refresh->SetCanFocus(false);
+    m_button_refresh->SetBorderWidth(0);
+    toolbar->Add(m_button_refresh, 0, wxALIGN_CENTER_VERTICAL | wxRIGHT, 24);
+    sizer->Add(toolbar, 0, wxEXPAND);
+
+    m_image_grid = new ImageGrid(this);
+    // Theme this grid instance without changing the shared Bambu defaults.
+    m_image_grid->SetBackgroundColour(GetBackgroundColour());
+    m_image_grid->SetSelecting(false);
+    m_image_grid->ShowDownload(false);
+    m_image_grid->SetStatus(m_bmp_failed, _L("Please confirm if the printer is connected."));
+    sizer->Add(m_image_grid, 1, wxEXPAND);
+    SetSizer(sizer);
+    applyThemeColors();
+    updateGroupButtons(m_group_mode);
+
+    auto group_clicked = [this](wxCommandEvent& event) {
+        const FileGridGroup mode = event.GetEventObject() == m_button_year ? FileGridGroup::Year :
+                                   event.GetEventObject() == m_button_month ? FileGridGroup::Month : FileGridGroup::All;
+        m_image_grid->SetGroupMode(static_cast<int>(mode));
+        updateGroupButtons(mode);
+    };
+    m_button_year->Bind(wxEVT_COMMAND_BUTTON_CLICKED, group_clicked);
+    m_button_month->Bind(wxEVT_COMMAND_BUTTON_CLICKED, group_clicked);
+    m_button_all->Bind(wxEVT_COMMAND_BUTTON_CLICKED, group_clicked);
+
+    m_button_refresh->Bind(wxEVT_COMMAND_BUTTON_CLICKED, [this](wxCommandEvent& event) {
+        event.Skip();
+        if (m_model)
+            m_model->Refresh();
+    });
+
+    m_image_grid->Bind(EVT_ITEM_ACTION, [this](wxCommandEvent& event) {
+        const int action = event.GetInt();
+        if (!m_model || m_device_id.empty())
+            return;
+
+        const size_t index = static_cast<size_t>(event.GetExtraLong());
+        if (index >= m_model->GetCount())
+            return;
+        const FileGridCard& card = m_model->GetFile(index);
+        if (card.id.empty())
+            return;
+        const std::string path = card.id;
+        const std::string name = card.name;
+
+        if (action == 0) {
+            MessageDialog dlg(this,
+                wxString::Format(_L("Do you want to delete the file '%s' from printer?"), from_u8(name)),
+                _L("Delete file"), wxYES_NO | wxICON_WARNING);
+            if (dlg.ShowModal() != wxID_YES)
+                return;
+
+            m_model->DeleteFile(path, [this](bool ok) {
+                if (ok)
+                    return;
+                MessageDialog(this, _L("Failed to delete the file from printer."), _L("Delete file"),
+                              wxOK | wxICON_ERROR).ShowModal();
+            });
+        } else if (action == 1) {
+            // Print is .gcode-only for now; .gcode.3mf support to be added later.
+            MessageDialog dlg(this,
+                wxString::Format(_L("Do you want to print the file '%s' from printer?"), from_u8(name)),
+                _L("Print file"), wxYES_NO | wxICON_WARNING);
+            if (dlg.ShowModal() != wxID_YES)
+                return;
+
+            NetworkAgent* agent = wxGetApp().getAgent();
+            if (!agent)
+                return;
+
+            PrintParams params;
+            params.dev_id          = m_device_id;
+            params.dst_file        = path;
+            params.connection_type = "lan";
+            if (agent->start_sdcard_print(params, {}, {}) != BAMBU_NETWORK_SUCCESS)
+                MessageDialog(this, _L("Failed to start the print job."), _L("Print file"),
+                              wxOK | wxICON_ERROR).ShowModal();
+        }
+    });
+}
+
+OrcaFilesPanel::~OrcaFilesPanel()
+{
+    if (m_model)
+        m_model->SetStatusHandler({});
+    if (m_model)
+        m_model->SetGroupModeHandler({});
+    m_image_grid->SetModel(nullptr);
+    m_model.reset();
+}
+
+void OrcaFilesPanel::UpdateByObj(MachineObject* obj)
+{
+    const std::string device_id = obj ? obj->get_dev_id() : std::string();
+    if (device_id == m_device_id)
+        return;
+
+    m_device_id = device_id;
+    if (m_model)
+        m_model->SetStatusHandler({});
+    if (m_model)
+        m_model->SetGroupModeHandler({});
+    m_image_grid->SetModel(nullptr);
+    m_model.reset();
+
+    if (m_device_id.empty()) {
+        m_button_refresh->Enable(false);
+        m_image_grid->SetStatus(m_bmp_failed, _L("Please confirm if the printer is connected."));
+        return;
+    }
+
+    m_model = boost::make_shared<RemoteFileGridModel>(m_device_id);
+    m_model->SetStatusHandler([this](RemoteFileGridModel::Status status) { updateStatus(status); });
+    m_model->SetGroupModeHandler([this](FileGridGroup mode) { updateGroupButtons(mode); });
+    m_model->SetGroupMode(m_group_mode);
+    m_image_grid->SetModel(m_model);
+    m_image_grid->SetFileType(static_cast<int>(FileGridType::Model), {});
+    m_button_refresh->Enable(true);
+    m_model->Refresh();
+}
+
+void OrcaFilesPanel::updateStatus(RemoteFileGridModel::Status status)
+{
+    switch (status) {
+    case RemoteFileGridModel::Status::Loading:
+        m_image_grid->SetStatus(m_bmp_loading, _L("Loading file list..."));
+        break;
+    case RemoteFileGridModel::Status::Ready:
+        break;
+    case RemoteFileGridModel::Status::Empty:
+        m_image_grid->SetStatus(m_bmp_empty, _L("No files"));
+        break;
+    case RemoteFileGridModel::Status::Failed:
+        m_image_grid->SetStatus(m_bmp_failed, _L("Load failed"));
+        break;
+    }
+}
+
+void OrcaFilesPanel::Rescale()
+{
+    m_bmp_loading.msw_rescale();
+    m_bmp_failed.msw_rescale();
+    m_bmp_empty.msw_rescale();
+
+    auto* toolbar = GetSizer()->GetItem(static_cast<size_t>(0))->GetSizer();
+    toolbar->SetMinSize({-1, 75 * em_unit(this) / 10});
+    m_root_label->SetFont(Label::Head_16);
+    m_button_refresh->Rescale();
+    m_button_year->Rescale();
+    m_button_month->Rescale();
+    m_button_all->Rescale();
+    m_image_grid->Rescale();
+}
+
+void OrcaFilesPanel::on_sys_color_changed()
+{
+    applyThemeColors();
+    Layout();
+    Refresh();
+}
+
+void OrcaFilesPanel::applyThemeColors()
+{
+    const bool dark = wxGetApp().dark_mode();
+    const wxColour light_background("#EEEEEE");
+    const wxColour light_text("#262E30");
+    const wxColour light_teal("#009688");
+    const wxColour background = dark ? StateColor::darkModeColorFor(light_background) : light_background;
+
+    SetBackgroundColour(background);
+    m_root_label->SetBackgroundColour(background);
+    m_root_label->SetForegroundColour(dark ? StateColor::darkModeColorFor(light_text) : light_text);
+    m_time_panel->SetBackgroundColour(background);
+    m_button_refresh->SetBackgroundColorNormal(dark ? StateColor::darkModeColorFor(light_teal) : light_teal);
+    m_button_refresh->SetTextColorNormal(*wxWHITE);
+    m_image_grid->SetBackgroundColour(background);
+    m_image_grid->Refresh();
+    m_button_year->Refresh();
+    m_button_month->Refresh();
+    m_button_all->Refresh();
+}
+
+void OrcaFilesPanel::updateGroupButtons(FileGridGroup mode)
+{
+    m_group_mode = mode;
+    ::Button* buttons[] = {m_button_all, m_button_month, m_button_year};
+    const int selected = static_cast<int>(mode);
+    for (int i = 0; i < 3; ++i) {
+        buttons[i]->SetValue(i == selected);
+        buttons[i]->SetFont(i == selected ? Label::Head_14 : Label::Body_14);
+    }
+}
+
+}}

src/slic3r/GUI/OrcaFilesPanel.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "GUI_Utils.hpp"
+#include "wxExtensions.hpp"
+#include "Printer/RemoteFileGridModel.h"
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <wx/panel.h>
+
+class Button;
+class Label;
+class StaticBox;
+
+namespace Slic3r {
+class MachineObject;
+
+namespace GUI {
+
+class ImageGrid;
+
+class OrcaFilesPanel : public wxPanel
+{
+public:
+    explicit OrcaFilesPanel(wxWindow* parent);
+    ~OrcaFilesPanel() override;
+
+    void UpdateByObj(MachineObject* obj);
+    void Rescale();
+    void on_sys_color_changed();
+
+private:
+    void applyThemeColors();
+    void updateGroupButtons(FileGridGroup mode);
+    void updateStatus(RemoteFileGridModel::Status status);
+
+    ScalableBitmap m_bmp_loading;
+    ScalableBitmap m_bmp_failed;
+    ScalableBitmap m_bmp_empty;
+    Label* m_root_label = nullptr;
+    ::StaticBox* m_time_panel = nullptr;
+    ::Button* m_button_year = nullptr;
+    ::Button* m_button_month = nullptr;
+    ::Button* m_button_all = nullptr;
+    ::Button* m_button_refresh = nullptr;
+    ImageGrid* m_image_grid = nullptr;
+    boost::shared_ptr<RemoteFileGridModel> m_model;
+    std::string m_device_id;
+    FileGridGroup m_group_mode = FileGridGroup::All;
+};
+
+}}

src/slic3r/GUI/Printer/BambuFileGridModel.cpp

@@ -0,0 +1,197 @@
+#include "BambuFileGridModel.h"
+
+#include "slic3r/GUI/GUI_App.hpp"
+
+#include <utility>
+
+namespace Slic3r {
+namespace GUI {
+
+static const FileGridCard& emptyCard()
+{
+    static const FileGridCard card;
+    return card;
+}
+
+BambuFileGridModel::BambuFileGridModel(boost::shared_ptr<PrinterFileSystem> fs)
+    : m_fs(std::move(fs))
+{
+    if (m_fs) {
+        m_fs->Bind(EVT_FILE_CHANGED, &BambuFileGridModel::onFileChanged, this);
+        m_fs->Bind(EVT_MODE_CHANGED, &BambuFileGridModel::onModeChanged, this);
+        m_fs->Bind(EVT_THUMBNAIL, &BambuFileGridModel::onThumbnail, this);
+        m_fs->Bind(EVT_DOWNLOAD, &BambuFileGridModel::onDownload, this);
+    }
+}
+
+BambuFileGridModel::~BambuFileGridModel()
+{
+    if (m_fs) {
+        m_fs->Unbind(EVT_FILE_CHANGED, &BambuFileGridModel::onFileChanged, this);
+        m_fs->Unbind(EVT_MODE_CHANGED, &BambuFileGridModel::onModeChanged, this);
+        m_fs->Unbind(EVT_THUMBNAIL, &BambuFileGridModel::onThumbnail, this);
+        m_fs->Unbind(EVT_DOWNLOAD, &BambuFileGridModel::onDownload, this);
+    }
+}
+
+void BambuFileGridModel::EnsureCards() const
+{
+    if (!m_dirty && (!m_fs || m_cards.size() == m_fs->GetCount()))
+        return;
+    m_dirty = false;
+    m_cards.clear();
+    if (!m_fs)
+        return;
+    size_t count = m_fs->GetCount();
+    m_cards.reserve(count);
+    for (size_t i = 0; i < count; ++i) {
+        bool selected = false;
+        PrinterFileSystem::File const &file = m_fs->GetFile(i, selected);
+        FileGridCard card;
+        card.id                = file.path;
+        card.name              = file.name;
+        card.title             = file.Title();
+        card.time_text         = file.Metadata("Time", "");
+        card.weight_text       = file.Metadata("Weight", "");
+        card.time              = file.time;
+        card.downloading       = file.IsDownload();
+        card.download_progress = file.DownloadProgress();
+        card.selected          = selected;
+        card.thumbnail         = file.thumbnail;
+        m_cards.push_back(std::move(card));
+    }
+}
+
+size_t BambuFileGridModel::GetCount() const
+{
+    return m_fs ? m_fs->GetCount() : 0;
+}
+
+const FileGridCard& BambuFileGridModel::GetFile(size_t index, bool& selected) const
+{
+    EnsureCards();
+    if (!m_fs || index >= m_cards.size()) {
+        selected = false;
+        return emptyCard();
+    }
+    m_fs->GetFile(index, selected);
+    return m_cards[index];
+}
+
+const FileGridCard& BambuFileGridModel::GetFile(size_t index) const
+{
+    EnsureCards();
+    if (index >= m_cards.size())
+        return emptyCard();
+    return m_cards[index];
+}
+
+FileGridType BambuFileGridModel::GetFileType() const
+{
+    return m_fs ? static_cast<FileGridType>(m_fs->GetFileType()) : FileGridType::Timelapse;
+}
+
+void BambuFileGridModel::SetFileType(FileGridType type, const std::string& storage)
+{
+    if (m_fs)
+        m_fs->SetFileType(static_cast<PrinterFileSystem::FileType>(type), storage);
+}
+
+FileGridGroup BambuFileGridModel::GetGroupMode() const
+{
+    return m_fs ? static_cast<FileGridGroup>(m_fs->GetGroupMode()) : FileGridGroup::All;
+}
+
+void BambuFileGridModel::SetGroupMode(FileGridGroup mode)
+{
+    if (m_fs)
+        m_fs->SetGroupMode(static_cast<PrinterFileSystem::GroupMode>(mode));
+}
+
+size_t BambuFileGridModel::GetIndexAtTime(time_t time) const
+{
+    return m_fs ? m_fs->GetIndexAtTime(static_cast<boost::uint32_t>(time)) : 0;
+}
+
+size_t BambuFileGridModel::EnterSubGroup(size_t index)
+{
+    return m_fs ? m_fs->EnterSubGroup(index) : index;
+}
+
+void BambuFileGridModel::ToggleSelect(size_t index)
+{
+    if (m_fs)
+        m_fs->ToggleSelect(index);
+}
+
+void BambuFileGridModel::SelectAll(bool select)
+{
+    if (m_fs)
+        m_fs->SelectAll(select);
+}
+
+void BambuFileGridModel::SetFocusRange(size_t start, size_t count)
+{
+    if (m_fs)
+        m_fs->SetFocusRange(start, count);
+}
+
+void BambuFileGridModel::Retry()
+{
+    if (m_fs)
+        m_fs->Retry();
+}
+
+int BambuFileGridModel::GetLastError() const
+{
+    return m_fs ? m_fs->GetLastError() : 1;
+}
+
+void BambuFileGridModel::DownloadCheckFiles(const std::string& path)
+{
+    if (m_fs)
+        m_fs->DownloadCheckFiles(path);
+}
+
+void BambuFileGridModel::SetChangeHandler(std::function<void(FileGridChange)> handler)
+{
+    m_handler = std::move(handler);
+}
+
+void BambuFileGridModel::notify(FileGridChange change)
+{
+    if (m_handler)
+        m_handler(change);
+}
+
+void BambuFileGridModel::onFileChanged(wxCommandEvent& evt)
+{
+    evt.Skip();
+    if (evt.GetInt() == -1 && m_fs)
+        m_fs->DownloadCheckFiles(wxGetApp().app_config->get("download_path"));
+    m_dirty = true;
+    notify(FileGridChange::Files);
+}
+
+void BambuFileGridModel::onModeChanged(wxCommandEvent& evt)
+{
+    evt.Skip();
+    m_dirty = true;
+    notify(FileGridChange::Mode);
+}
+
+void BambuFileGridModel::onThumbnail(wxCommandEvent& evt)
+{
+    evt.Skip();
+    m_dirty = true;
+    notify(FileGridChange::Thumbnail);
+}
+
+void BambuFileGridModel::onDownload(wxCommandEvent& evt)
+{
+    evt.Skip();
+    m_dirty = true;
+    notify(FileGridChange::Download);
+}
+
+}}

src/slic3r/GUI/Printer/BambuFileGridModel.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include "IFileGridModel.h"
+#include "PrinterFileSystem.h"
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <wx/event.h>
+#include <cstddef>
+#include <ctime>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace Slic3r {
+namespace GUI {
+
+// IFileGridModel over PrinterFileSystem, behavior-identical to ImageGrid's direct use.
+class BambuFileGridModel : public wxEvtHandler, public IFileGridModel
+{
+public:
+    explicit BambuFileGridModel(boost::shared_ptr<PrinterFileSystem> fs);
+    ~BambuFileGridModel() override;
+
+    size_t GetCount() const override;
+    const FileGridCard& GetFile(size_t index, bool& selected) const override;
+    const FileGridCard& GetFile(size_t index) const override;
+
+    FileGridType  GetFileType() const override;
+    void          SetFileType(FileGridType type, const std::string& storage) override;
+    FileGridGroup GetGroupMode() const override;
+    void          SetGroupMode(FileGridGroup mode) override;
+
+    size_t GetIndexAtTime(time_t time) const override;
+    size_t EnterSubGroup(size_t index) override;
+
+    void ToggleSelect(size_t index) override;
+    void SelectAll(bool select) override;
+    void SetFocusRange(size_t start, size_t count) override;
+
+    void Retry() override;
+    int  GetLastError() const override;
+    void DownloadCheckFiles(const std::string& path) override;
+
+    void SetChangeHandler(std::function<void(FileGridChange)> handler) override;
+
+private:
+    void EnsureCards() const;
+    void notify(FileGridChange change);
+
+    void onFileChanged(wxCommandEvent& evt);
+    void onModeChanged(wxCommandEvent& evt);
+    void onThumbnail(wxCommandEvent& evt);
+    void onDownload(wxCommandEvent& evt);
+
+    boost::shared_ptr<PrinterFileSystem> m_fs;
+    std::function<void(FileGridChange)>  m_handler;
+    mutable std::vector<FileGridCard>    m_cards;
+    mutable bool                         m_dirty = true;
+};
+
+}}

src/slic3r/GUI/Printer/IFileGridModel.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <wx/bitmap.h>
+#include <cstddef>
+#include <ctime>
+#include <functional>
+#include <string>
+
+namespace Slic3r {
+namespace GUI {
+
+// Mirrors PrinterFileSystem::FileType ordering (F_TIMELAPSE=0, F_VIDEO=1, F_MODEL=2).
+enum class FileGridType { Timelapse = 0, Video = 1, Model = 2 };
+// Mirrors PrinterFileSystem::GroupMode ordering (G_NONE=0, G_MONTH=1, G_YEAR=2).
+enum class FileGridGroup { All = 0, Month = 1, Year = 2 };
+// Mirrors the PrinterFileSystem wx events ImageGrid listens to.
+enum class FileGridChange { Files, Mode, Thumbnail, Download };
+
+// One rendered card. Neutral: no Bambu transfer internals, no filesystem paths beyond id.
+struct FileGridCard {
+    std::string id;
+    std::string name;
+    std::string title;
+    std::string time_text;
+    std::string weight_text;
+    time_t      time = 0;
+    bool        downloading = false;
+    int         download_progress = 0; // -1 waiting, <0 failed, 0..100 progress
+    bool        selected = false;
+    bool        printable = true;
+    wxBitmap    thumbnail;
+};
+
+// Data source behind ImageGrid. Implemented today by BambuFileGridModel (wrapping
+// PrinterFileSystem); a non-Bambu model can implement the same surface later.
+class IFileGridModel {
+public:
+    virtual ~IFileGridModel() = default;
+
+    virtual size_t GetCount() const = 0;
+    virtual const FileGridCard& GetFile(size_t index, bool& selected) const = 0;
+    virtual const FileGridCard& GetFile(size_t index) const = 0;
+
+    virtual FileGridType  GetFileType() const = 0;
+    virtual void          SetFileType(FileGridType type, const std::string& storage) = 0;
+    virtual FileGridGroup GetGroupMode() const = 0;
+    virtual void          SetGroupMode(FileGridGroup mode) = 0;
+
+    // When true, the thumbnail is fitted inside the tile instead of stretched to fill it.
+    virtual bool preserve_thumbnail_aspect() const { return false; }
+
+    virtual size_t GetIndexAtTime(time_t time) const = 0;
+    virtual size_t EnterSubGroup(size_t index) = 0;
+
+    virtual void ToggleSelect(size_t index) = 0;
+    virtual void SelectAll(bool select) = 0;
+    virtual void SetFocusRange(size_t start, size_t count) = 0;
+
+    virtual void Retry() = 0;
+    virtual int  GetLastError() const = 0;
+    virtual void DownloadCheckFiles(const std::string& path) = 0;
+
+    // ImageGrid sets one handler; the model invokes it on the UI thread on change.
+    virtual void SetChangeHandler(std::function<void(FileGridChange)>) = 0;
+};
+
+}}

src/slic3r/GUI/Printer/RemoteFileGridModel.cpp

@@ -0,0 +1,534 @@
+#include "RemoteFileGridModel.h"
+
+#include "slic3r/GUI/GUI_App.hpp"
+#include "slic3r/Utils/NetworkAgent.hpp"
+
+#include <wx/datetime.h>
+#include <wx/image.h>
+#include <wx/mstream.h>
+
+#include <boost/format.hpp>
+#include <boost/regex.hpp>
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <utility>
+
+namespace Slic3r {
+namespace GUI {
+
+namespace {
+
+const FileGridCard& emptyCard()
+{
+    static const FileGridCard card;
+    return card;
+}
+
+// Same display format as PrinterFileSystem: "1d2h3m", dropping a leading "0d"/"0h".
+std::string durationString(long duration)
+{
+    static boost::regex rx("^0d(0h)?");
+    auto time = boost::format("%1%d%2%h%3%m") % (duration / 86400) % ((duration % 86400) / 3600) % ((duration % 3600) / 60);
+    return boost::regex_replace(time.str(), rx, "");
+}
+
+// Case-insensitive suffix test shared by the file filters below.
+bool ends_with_ci(const std::string& name, const std::string& suffix)
+{
+    return name.size() >= suffix.size() &&
+           std::equal(suffix.rbegin(), suffix.rend(), name.rbegin(),
+                      [](char a, char b) {
+                          return std::tolower(static_cast<unsigned char>(a)) ==
+                                 std::tolower(static_cast<unsigned char>(b));
+                      });
+}
+
+// .gcode / .3mf only, case-insensitive; a .gcode.3mf name matches via the .3mf suffix.
+bool is_displayable_file(const std::string& name)
+{
+    return ends_with_ci(name, ".gcode") || ends_with_ci(name, ".3mf");
+}
+
+// Only .gcode is printable today; .gcode.3mf support to be added later.
+bool is_printable_gcode(const std::string& name)
+{
+    return ends_with_ci(name, ".gcode");
+}
+
+}
+
+RemoteFileGridModel::RemoteFileGridModel(std::string device_id)
+    : m_device_id(std::move(device_id))
+{
+}
+
+RemoteFileGridModel::~RemoteFileGridModel()
+{
+    m_lifetime.reset();
+}
+
+void RemoteFileGridModel::Refresh()
+{
+    const std::uint64_t request = ++m_request;
+    const std::string device_id = m_device_id;
+    m_thumbnail_cache.clear();
+    m_thumbnail_requested.clear();
+    m_thumbnail_queue.clear();
+    m_metadata_cache.clear();
+    m_metadata_requested.clear();
+    m_metadata_queue.clear();
+    for (FileGridCard& card : m_cards)
+        card.thumbnail = wxBitmap();
+    m_last_error = 0;
+    setStatus(Status::Loading);
+
+    NetworkAgent* agent = wxGetApp().getAgent();
+    if (!agent) {
+        m_last_error = -1;
+        m_cards.clear();
+        m_month.clear();
+        m_year.clear();
+        setStatus(Status::Failed);
+        if (m_change_handler)
+            m_change_handler(FileGridChange::Files);
+        return;
+    }
+
+    std::weak_ptr<int> lifetime = m_lifetime;
+    int result = agent->list_printer_files(device_id,
+        [this, lifetime, request, device_id](int result, std::vector<PrinterFileEntry> files) {
+            if (lifetime.expired())
+                return;
+            onFilesLoaded(request, device_id, result, std::move(files));
+        });
+
+    if (result != 0 && request == m_request && m_status == Status::Loading) {
+        m_last_error = result;
+        m_cards.clear();
+        m_month.clear();
+        m_year.clear();
+        setStatus(Status::Failed);
+        if (m_change_handler)
+            m_change_handler(FileGridChange::Files);
+    }
+}
+
+void RemoteFileGridModel::onFilesLoaded(std::uint64_t request, const std::string& device_id, int result,
+                                        std::vector<PrinterFileEntry> files)
+{
+    if (request != m_request || device_id != m_device_id)
+        return;
+
+    m_last_error = result;
+    m_cards.clear();
+    if (result == 0) {
+        files.erase(std::remove_if(files.begin(), files.end(),
+                                   [](const PrinterFileEntry& file) { return !is_displayable_file(file.name); }),
+                    files.end());
+        std::sort(files.begin(), files.end(), [](const PrinterFileEntry& lhs, const PrinterFileEntry& rhs) {
+            return lhs.modified > rhs.modified;
+        });
+        m_cards.reserve(files.size());
+        for (const PrinterFileEntry& file : files) {
+            FileGridCard card;
+            card.id = file.path;
+            card.name = file.name;
+            card.time = static_cast<time_t>(file.modified);
+            card.printable = is_printable_gcode(file.name);
+            m_cards.emplace_back(std::move(card));
+        }
+        buildGroups();
+        setStatus(m_cards.empty() ? Status::Empty : Status::Ready);
+    } else {
+        m_month.clear();
+        m_year.clear();
+        setStatus(Status::Failed);
+    }
+
+    if (m_change_handler)
+        m_change_handler(FileGridChange::Files);
+}
+
+void RemoteFileGridModel::setStatus(Status status)
+{
+    m_status = status;
+    if (m_status_handler)
+        m_status_handler(status);
+}
+
+void RemoteFileGridModel::SetStatusHandler(std::function<void(Status)> handler)
+{
+    m_status_handler = std::move(handler);
+}
+
+size_t RemoteFileGridModel::GetCount() const
+{
+    if (m_group_mode == FileGridGroup::Year)
+        return m_year.size();
+    if (m_group_mode == FileGridGroup::Month)
+        return m_month.size();
+    return m_cards.size();
+}
+
+const FileGridCard& RemoteFileGridModel::GetFile(size_t index, bool& selected) const
+{
+    selected = false;
+    const size_t card_index = cardIndexForGroup(index);
+    if (card_index >= m_cards.size())
+        return emptyCard();
+    FileGridCard& card = m_cards[card_index];
+    const auto thumbnail = m_thumbnail_cache.find(card.id);
+    card.thumbnail = thumbnail == m_thumbnail_cache.end() ? wxBitmap() : thumbnail->second;
+    return card;
+}
+
+const FileGridCard& RemoteFileGridModel::GetFile(size_t index) const
+{
+    bool selected = false;
+    return GetFile(index, selected);
+}
+
+size_t RemoteFileGridModel::cardIndexForGroup(size_t index) const
+{
+    if (m_group_mode == FileGridGroup::All)
+        return index;
+    if (m_group_mode == FileGridGroup::Month)
+        return index < m_month.size() ? m_month[index] : m_cards.size();
+    return index < m_year.size() && m_year[index] < m_month.size() ? m_month[m_year[index]] : m_cards.size();
+}
+
+FileGridType RemoteFileGridModel::GetFileType() const
+{
+    return m_file_type;
+}
+
+void RemoteFileGridModel::SetFileType(FileGridType type, const std::string&)
+{
+    m_file_type = type;
+}
+
+FileGridGroup RemoteFileGridModel::GetGroupMode() const
+{
+    return m_group_mode;
+}
+
+void RemoteFileGridModel::SetGroupMode(FileGridGroup mode)
+{
+    if (mode != FileGridGroup::All && mode != FileGridGroup::Month && mode != FileGridGroup::Year)
+        return;
+    if (m_group_mode == mode)
+        return;
+    m_group_mode = mode;
+    if (m_group_mode_handler)
+        m_group_mode_handler(mode);
+    if (m_change_handler)
+        m_change_handler(FileGridChange::Mode);
+}
+
+size_t RemoteFileGridModel::GetIndexAtTime(time_t time) const
+{
+    if (m_cards.empty())
+        return 0;
+
+    size_t low = 0;
+    size_t high = m_cards.size();
+    while (low < high) {
+        const size_t middle = low + (high - low) / 2;
+        if (m_cards[middle].time >= time)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    const size_t card_index = low == 0 ? 0 : low - 1;
+    if (m_group_mode == FileGridGroup::All)
+        return card_index;
+
+    const auto month = std::upper_bound(m_month.begin(), m_month.end(), card_index);
+    const size_t month_index = month == m_month.begin() ? 0 : static_cast<size_t>(month - m_month.begin() - 1);
+    if (m_group_mode == FileGridGroup::Month)
+        return month_index;
+
+    const auto year = std::upper_bound(m_year.begin(), m_year.end(), card_index,
+        [this](size_t file_index, size_t month_index) {
+            return file_index < m_month[month_index];
+        });
+    return year == m_year.begin() ? 0 : static_cast<size_t>(year - m_year.begin() - 1);
+}
+
+size_t RemoteFileGridModel::EnterSubGroup(size_t index)
+{
+    if (m_group_mode == FileGridGroup::All)
+        return index;
+    if (m_group_mode == FileGridGroup::Year) {
+        if (index >= m_year.size())
+            return 0;
+        index = m_year[index];
+    } else {
+        if (index >= m_month.size())
+            return 0;
+        index = m_month[index];
+    }
+    SetGroupMode(static_cast<FileGridGroup>(static_cast<int>(m_group_mode) - 1));
+    return index;
+}
+
+void RemoteFileGridModel::ToggleSelect(size_t)
+{
+}
+
+void RemoteFileGridModel::SelectAll(bool)
+{
+}
+
+void RemoteFileGridModel::SetFocusRange(size_t start, size_t count)
+{
+    if (m_status == Status::Loading || start >= GetCount())
+        return;
+    const size_t end = start + std::min(count, GetCount() - start);
+    for (size_t i = start; i < end; ++i) {
+        const FileGridCard& card = GetFile(i);
+        if (!card.id.empty()) {
+            requestThumbnail(card.id);
+            requestMetadata(card.id);
+        }
+    }
+    pumpThumbnailQueue();
+    pumpMetadataQueue();
+}
+
+void RemoteFileGridModel::Retry()
+{
+    Refresh();
+}
+
+int RemoteFileGridModel::GetLastError() const
+{
+    return m_last_error;
+}
+
+void RemoteFileGridModel::DownloadCheckFiles(const std::string&)
+{
+}
+
+void RemoteFileGridModel::DeleteFile(const std::string& path, std::function<void(bool ok)> done)
+{
+    NetworkAgent* agent = wxGetApp().getAgent();
+    if (!agent || m_device_id.empty() || path.empty()) {
+        if (done)
+            done(false);
+        return;
+    }
+
+    const std::uint64_t request = m_request;
+    const std::string device_id = m_device_id;
+    const std::weak_ptr<int> lifetime = m_lifetime;
+    const auto completed = std::make_shared<bool>(false);
+    auto finish = [this, lifetime, completed, request, device_id, path, done = std::move(done)](int result) {
+        if (*completed)
+            return;
+        *completed = true;
+        if (lifetime.expired())
+            return;
+
+        const bool ok = result == 0;
+        if (ok && request == m_request && device_id == m_device_id) {
+            m_thumbnail_cache.erase(path);
+            m_thumbnail_requested.erase(path);
+            m_cards.erase(std::remove_if(m_cards.begin(), m_cards.end(),
+                                         [&path](const FileGridCard& card) { return card.id == path; }),
+                          m_cards.end());
+            buildGroups();
+            setStatus(m_cards.empty() ? Status::Empty : Status::Ready);
+            if (m_change_handler)
+                m_change_handler(FileGridChange::Files);
+        }
+        if (done)
+            done(ok);
+    };
+
+    const int result = agent->delete_printer_file(device_id, path, finish);
+    if (result != 0)
+        finish(result);
+}
+
+void RemoteFileGridModel::SetChangeHandler(std::function<void(FileGridChange)> handler)
+{
+    m_change_handler = std::move(handler);
+}
+
+void RemoteFileGridModel::SetGroupModeHandler(std::function<void(FileGridGroup)> handler)
+{
+    m_group_mode_handler = std::move(handler);
+}
+
+void RemoteFileGridModel::buildGroups()
+{
+    m_month.clear();
+    m_year.clear();
+    if (m_cards.empty())
+        return;
+
+    m_month.push_back(0);
+    m_year.push_back(0);
+    wxDateTime previous(static_cast<time_t>(m_cards.front().time));
+    for (size_t i = 1; i < m_cards.size(); ++i) {
+        const wxDateTime current(static_cast<time_t>(m_cards[i].time));
+        if (current.GetYear() != previous.GetYear()) {
+            m_year.push_back(m_month.size());
+            m_month.push_back(i);
+        } else if (current.GetMonth() != previous.GetMonth()) {
+            m_month.push_back(i);
+        }
+        previous = current;
+    }
+}
+
+void RemoteFileGridModel::requestThumbnail(const std::string& path)
+{
+    if (m_thumbnail_cache.find(path) != m_thumbnail_cache.end() || !m_thumbnail_requested.insert(path).second)
+        return;
+    m_thumbnail_queue.push_back(path);
+}
+
+void RemoteFileGridModel::pumpThumbnailQueue()
+{
+    constexpr size_t MAX_THUMBNAIL_REQUESTS = 4;
+    if (m_pumping_thumbnail_queue)
+        return;
+    m_pumping_thumbnail_queue = true;
+
+    NetworkAgent* agent = wxGetApp().getAgent();
+    if (!agent) {
+        while (!m_thumbnail_queue.empty()) {
+            m_thumbnail_cache.emplace(m_thumbnail_queue.front(), wxBitmap());
+            m_thumbnail_queue.pop_front();
+        }
+        m_pumping_thumbnail_queue = false;
+        return;
+    }
+
+    while (!m_thumbnail_queue.empty() && m_thumbnail_requests_in_flight < MAX_THUMBNAIL_REQUESTS) {
+        std::string path = std::move(m_thumbnail_queue.front());
+        m_thumbnail_queue.pop_front();
+        ++m_thumbnail_requests_in_flight;
+
+        const std::uint64_t request = m_request;
+        const std::string device_id = m_device_id;
+        const std::weak_ptr<int> lifetime = m_lifetime;
+        const auto completed = std::make_shared<bool>(false);
+        auto finish = [this, lifetime, completed, request, device_id, path](int result, std::string image) {
+            if (*completed)
+                return;
+            *completed = true;
+            if (lifetime.expired())
+                return;
+            onThumbnailLoaded(request, device_id, path, result, std::move(image));
+        };
+
+        const int result = agent->get_printer_file_thumbnail(device_id, path, finish);
+        if (result != 0)
+            finish(result, {});
+    }
+    m_pumping_thumbnail_queue = false;
+}
+
+void RemoteFileGridModel::onThumbnailLoaded(std::uint64_t request, const std::string& device_id,
+                                            const std::string& path, int result, std::string image)
+{
+    if (m_thumbnail_requests_in_flight > 0)
+        --m_thumbnail_requests_in_flight;
+
+    if (request == m_request && device_id == m_device_id) {
+        wxBitmap bitmap;
+        if (result == 0 && !image.empty()) {
+            wxMemoryInputStream stream(image.data(), image.size());
+            wxImage decoded(stream, wxBITMAP_TYPE_PNG);
+            if (decoded.IsOk())
+                bitmap = wxBitmap(decoded);
+        }
+        m_thumbnail_cache[path] = std::move(bitmap);
+        if (m_change_handler)
+            m_change_handler(FileGridChange::Thumbnail);
+    }
+
+    pumpThumbnailQueue();
+}
+
+void RemoteFileGridModel::requestMetadata(const std::string& path)
+{
+    if (m_metadata_cache.find(path) != m_metadata_cache.end() || !m_metadata_requested.insert(path).second)
+        return;
+    m_metadata_queue.push_back(path);
+}
+
+void RemoteFileGridModel::pumpMetadataQueue()
+{
+    constexpr size_t MAX_METADATA_REQUESTS = 4;
+    if (m_pumping_metadata_queue)
+        return;
+    m_pumping_metadata_queue = true;
+
+    NetworkAgent* agent = wxGetApp().getAgent();
+    if (!agent) {
+        while (!m_metadata_queue.empty()) {
+            m_metadata_cache.emplace(m_metadata_queue.front(), PrinterFileMetadata{});
+            m_metadata_queue.pop_front();
+        }
+        m_pumping_metadata_queue = false;
+        return;
+    }
+
+    while (!m_metadata_queue.empty() && m_metadata_requests_in_flight < MAX_METADATA_REQUESTS) {
+        std::string path = std::move(m_metadata_queue.front());
+        m_metadata_queue.pop_front();
+        ++m_metadata_requests_in_flight;
+
+        const std::uint64_t request = m_request;
+        const std::string device_id = m_device_id;
+        const std::weak_ptr<int> lifetime = m_lifetime;
+        const auto completed = std::make_shared<bool>(false);
+        auto finish = [this, lifetime, completed, request, device_id, path](int result, PrinterFileMetadata meta) {
+            if (*completed)
+                return;
+            *completed = true;
+            if (lifetime.expired())
+                return;
+            onMetadataLoaded(request, device_id, path, result, meta);
+        };
+
+        const int result = agent->get_printer_file_metadata(device_id, path, finish);
+        if (result != 0)
+            finish(result, {});
+    }
+    m_pumping_metadata_queue = false;
+}
+
+void RemoteFileGridModel::onMetadataLoaded(std::uint64_t request, const std::string& device_id,
+                                           const std::string& path, int result, PrinterFileMetadata meta)
+{
+    if (m_metadata_requests_in_flight > 0)
+        --m_metadata_requests_in_flight;
+
+    if (request == m_request && device_id == m_device_id) {
+        m_metadata_cache[path] = meta;
+        if (result == 0) {
+            for (FileGridCard& card : m_cards) {
+                if (card.id != path)
+                    continue;
+                card.time_text   = meta.estimated_time > 0 ? durationString(meta.estimated_time) : std::string();
+                card.weight_text = meta.filament_weight > 0
+                                       ? std::to_string(int(std::round(meta.filament_weight))) + 'g'
+                                       : std::string();
+                break;
+            }
+            if (m_change_handler)
+                m_change_handler(FileGridChange::Thumbnail);
+        }
+    }
+
+    pumpMetadataQueue();
+}
+
+}}

src/slic3r/GUI/Printer/RemoteFileGridModel.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include "IFileGridModel.h"
+
+#include "slic3r/Utils/IPrinterAgent.hpp"
+
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+namespace Slic3r {
+namespace GUI {
+
+class RemoteFileGridModel : public IFileGridModel
+{
+public:
+    enum class Status { Loading, Ready, Empty, Failed };
+
+    explicit RemoteFileGridModel(std::string device_id);
+    ~RemoteFileGridModel() override;
+
+    void Refresh();
+    Status GetStatus() const { return m_status; }
+    void SetStatusHandler(std::function<void(Status)> handler);
+    void SetGroupModeHandler(std::function<void(FileGridGroup)> handler);
+
+    size_t GetCount() const override;
+    const FileGridCard& GetFile(size_t index, bool& selected) const override;
+    const FileGridCard& GetFile(size_t index) const override;
+
+    FileGridType GetFileType() const override;
+    void SetFileType(FileGridType type, const std::string& storage) override;
+    FileGridGroup GetGroupMode() const override;
+    void SetGroupMode(FileGridGroup mode) override;
+
+    size_t GetIndexAtTime(time_t time) const override;
+    size_t EnterSubGroup(size_t index) override;
+
+    void ToggleSelect(size_t index) override;
+    void SelectAll(bool select) override;
+    void SetFocusRange(size_t start, size_t count) override;
+
+    void Retry() override;
+    int GetLastError() const override;
+    void DownloadCheckFiles(const std::string& path) override;
+    bool preserve_thumbnail_aspect() const override { return true; }
+
+    // Delete `path` from the printer; `done` reports success on the UI thread.
+    void DeleteFile(const std::string& path, std::function<void(bool ok)> done);
+
+    void SetChangeHandler(std::function<void(FileGridChange)> handler) override;
+
+private:
+    void setStatus(Status status);
+    void onFilesLoaded(std::uint64_t request, const std::string& device_id, int result,
+                       std::vector<PrinterFileEntry> files);
+    void buildGroups();
+    size_t cardIndexForGroup(size_t index) const;
+    void requestThumbnail(const std::string& path);
+    void pumpThumbnailQueue();
+    void onThumbnailLoaded(std::uint64_t request, const std::string& device_id,
+                           const std::string& path, int result, std::string image);
+    void requestMetadata(const std::string& path);
+    void pumpMetadataQueue();
+    void onMetadataLoaded(std::uint64_t request, const std::string& device_id,
+                          const std::string& path, int result, PrinterFileMetadata meta);
+
+    std::string m_device_id;
+    mutable std::vector<FileGridCard> m_cards;
+    std::vector<size_t> m_month;
+    std::vector<size_t> m_year;
+    std::function<void(FileGridChange)> m_change_handler;
+    std::function<void(Status)> m_status_handler;
+    std::function<void(FileGridGroup)> m_group_mode_handler;
+    std::shared_ptr<int> m_lifetime = std::make_shared<int>(0);
+    std::unordered_map<std::string, wxBitmap> m_thumbnail_cache;
+    std::unordered_set<std::string> m_thumbnail_requested;
+    std::deque<std::string> m_thumbnail_queue;
+    std::unordered_map<std::string, PrinterFileMetadata> m_metadata_cache;
+    std::unordered_set<std::string> m_metadata_requested;
+    std::deque<std::string> m_metadata_queue;
+    std::uint64_t m_request = 0;
+    size_t m_thumbnail_requests_in_flight = 0;
+    bool m_pumping_thumbnail_queue = false;
+    size_t m_metadata_requests_in_flight = 0;
+    bool m_pumping_metadata_queue = false;
+    int m_last_error = 0;
+    FileGridType m_file_type = FileGridType::Timelapse;
+    FileGridGroup m_group_mode = FileGridGroup::All;
+    Status m_status = Status::Loading;
+};
+
+}}

src/slic3r/GUI/SelectMachine.cpp

@@ -37,6 +37,8 @@
 #include "libslic3r/MultiNozzleUtils.hpp" // filament-change-gap model for the best-position popup
 #include "BackgroundSlicingProcess.hpp"   // complete type for background_process().get_current_gcode_result()
 #include "DeviceCore/DevStorage.h"
+#include "slic3r/Utils/NetworkAgentFactory.hpp"
+#include "FilamentMappingUtils.hpp"
 
 #include <wx/event.h>
 #include <string>
@@ -3553,6 +3555,9 @@ void SelectMachineDialog::navigate_to_timelapse_page()
     this->EndModal(wxID_CANCEL);
 }
 
+// Mapping helpers live in FilamentMappingUtils.hpp (shared with
+// SendMultiMachinePage); they mirror the agent serializer exactly.
+
 void SelectMachineDialog::on_send_print()
 {
     BOOST_LOG_TRIVIAL(info) << "print_job: on_ok to send";
@@ -3607,6 +3612,28 @@ void SelectMachineDialog::on_send_print()
 
     get_ams_mapping_result(ams_mapping_array,ams_mapping_array2, ams_mapping_info);
 
+    // The policy lives in FilamentMappingUtils.hpp; this dialog only differs
+    // from the multi-device page in how it reports a refusal.
+    switch (prepare_filament_mapping_for_send(obj_, ams_mapping_array2, m_ams_mapping_result)) {
+    case MappingSendError::unsupported:
+        BOOST_LOG_TRIVIAL(warning) << "print_job: connector does not advertise filament_mapping; refusing mapped print";
+        m_status_bar->set_status_text(_L("AMS filament mapping is not available for this printer. Clear the AMS mapping before printing."));
+        Enable_Send_Button(true);
+        return;
+    case MappingSendError::incomplete:
+        BOOST_LOG_TRIVIAL(warning) << "print_job: a used filament has no AMS target; refusing print";
+        m_status_bar->set_status_text(_L("A filament used by this print has no AMS mapping. Assign it before printing."));
+        Enable_Send_Button(true);
+        return;
+    case MappingSendError::none:
+        break;
+    default:
+        // A refusal added without a handler here must not silently send.
+        BOOST_LOG_TRIVIAL(warning) << "print_job: unrecognized mapping refusal; refusing print";
+        Enable_Send_Button(true);
+        return;
+    }
+
     if (m_print_type == PrintFromType::FROM_NORMAL) {
         result = m_plater->send_gcode(m_print_plate_idx, [this](int export_stage, int current, int total, bool& cancel) {
             if (this->m_is_canceled) return;

src/slic3r/GUI/SendMultiMachinePage.cpp

@@ -61,6 +61,8 @@
 
 #include "DeviceCore/DevManager.h"
 #include "DeviceCore/DevStorage.h"
+#include "slic3r/Utils/NetworkAgentFactory.hpp"
+#include "FilamentMappingUtils.hpp"
 #include <boost/filesystem.hpp>
 
 namespace fs = boost::filesystem;
@@ -746,6 +748,8 @@ bool SendMultiMachinePage::get_ams_mapping_result(std::string &mapping_array_str
     return true;
 }
 
+// Mapping helpers live in FilamentMappingUtils.hpp, shared with SelectMachine.
+
 void SendMultiMachinePage::on_send(wxCommandEvent& event)
 {
     event.Skip();
@@ -794,6 +798,30 @@ void SendMultiMachinePage::on_send(wxCommandEvent& event)
 
             if (!wxGetApp().is_blocking_printing(obj)) {
                 PrintParams params = request_params(obj);
+                switch (prepare_filament_mapping_for_send(obj, params.ams_mapping2, m_ams_mapping_result)) {
+                case MappingSendError::unsupported:
+                {
+                    BOOST_LOG_TRIVIAL(warning) << "SendMultiMachinePage: connector does not advertise filament_mapping; refusing mapped print for "
+                                               << obj->get_dev_id();
+                    MessageDialog unavailable_msg(nullptr, _L("AMS filament mapping is not available for this printer. Clear the AMS mapping before printing."), "", wxICON_WARNING | wxOK);
+                    unavailable_msg.ShowModal();
+                    return;
+                }
+                case MappingSendError::incomplete:
+                {
+                    BOOST_LOG_TRIVIAL(warning) << "SendMultiMachinePage: a used filament has no target; refusing print for " << obj->get_dev_id();
+                    MessageDialog incomplete_msg(nullptr, _L("A filament used by this print has no AMS mapping. Assign it before printing."), "", wxICON_WARNING | wxOK);
+                    incomplete_msg.ShowModal();
+                    return;
+                }
+                case MappingSendError::none:
+                    break;
+                default:
+                    // A refusal added without a handler here must not silently send.
+                    BOOST_LOG_TRIVIAL(warning) << "SendMultiMachinePage: unrecognized mapping refusal for "
+                                               << obj->get_dev_id();
+                    return;
+                }
                 print_params.push_back(params);
             }
         }

src/slic3r/GUI/StatusPanel.cpp

@@ -4695,12 +4695,14 @@ void StatusPanel::on_filament_edit(wxCommandEvent &event)
                 }
 
                 m_filament_setting_dlg->m_is_third = !DevFilaSystem::IsBBL_Filament(tray->tag_uid);
+                // The tray's own temps pre-fill the dialog for every tray type; a BBL tray
+                // additionally carries the SN and brand.
+                temp_max = tray->nozzle_temp_max;
+                temp_min = tray->nozzle_temp_min;
                 if (!m_filament_setting_dlg->m_is_third)
                 {
                     sn_number = tray->uuid;
                     filament = tray->sub_brands;
-                    temp_max = tray->nozzle_temp_max;
-                    temp_min = tray->nozzle_temp_min;
                 }
             }
 
@@ -4761,11 +4763,11 @@ void StatusPanel::on_ext_spool_edit(wxCommandEvent &event)
             }
 
             m_filament_setting_dlg->m_is_third = !DevFilaSystem::IsBBL_Filament(obj->vt_slot[nozzle_index].tag_uid);
+            temp_max = obj->vt_slot[nozzle_index].nozzle_temp_max;
+            temp_min = obj->vt_slot[nozzle_index].nozzle_temp_min;
             if (!m_filament_setting_dlg->m_is_third) {
                 sn_number = obj->vt_slot[nozzle_index].uuid;
                 filament  = obj->vt_slot[nozzle_index].sub_brands;
-                temp_max  = obj->vt_slot[nozzle_index].nozzle_temp_max;
-                temp_min  = obj->vt_slot[nozzle_index].nozzle_temp_min;
             }
 
             m_filament_setting_dlg->Move(wxPoint(current_position_x,current_position_y));

src/slic3r/GUI/StoragePanel.cpp

@@ -0,0 +1,110 @@
+#include "StoragePanel.h"
+
+#include "DeviceManager.hpp"
+#include "GUI_App.hpp"
+#include "MediaFilePanel.h"
+#include "OrcaFilesPanel.h"
+#include "Widgets/StateColor.hpp"
+
+#include <wx/colour.h>
+#include <wx/sizer.h>
+
+namespace Slic3r {
+namespace GUI {
+
+StoragePanel::StoragePanel(wxWindow* parent)
+    : wxPanel(parent, wxID_ANY)
+{
+    const wxColour light_background("#EEEEEE");
+    SetBackgroundColour(wxGetApp().dark_mode() ? StateColor::darkModeColorFor(light_background) : light_background);
+    SetSizer(new wxBoxSizer(wxVERTICAL));
+}
+
+MediaFilePanel* StoragePanel::ensureBambuPanel()
+{
+    if (!m_bambu_panel) {
+        m_bambu_panel = new MediaFilePanel(this);
+        m_bambu_panel->Hide();
+        GetSizer()->Add(m_bambu_panel, 1, wxEXPAND);
+        wxGetApp().UpdateDarkUIWin(m_bambu_panel);
+    }
+    return m_bambu_panel;
+}
+
+OrcaFilesPanel* StoragePanel::ensureOrcaPanel()
+{
+    if (!m_orca_panel) {
+        m_orca_panel = new OrcaFilesPanel(this);
+        m_orca_panel->Hide();
+        GetSizer()->Add(m_orca_panel, 1, wxEXPAND);
+        wxGetApp().UpdateDarkUIWin(m_orca_panel);
+    }
+    return m_orca_panel;
+}
+
+void StoragePanel::showChild(Child child)
+{
+    if (m_bambu_panel)
+        m_bambu_panel->Show(child == Child::Bambu);
+    if (m_orca_panel)
+        m_orca_panel->Show(child == Child::Orca);
+    m_active_child = child;
+    Layout();
+}
+
+void StoragePanel::UpdateByObj(MachineObject* obj)
+{
+    // Agent capability controls the page; Bambu remains the fallback for other printers.
+    Child target = m_active_child;
+    if (obj)
+        target = obj->printer_supports_feature("printer_files") ? Child::Orca : Child::Bambu;
+    else if (target == Child::None)
+        target = Child::Bambu;
+
+    if (target != m_active_child) {
+        if (m_active_child == Child::Bambu && m_bambu_panel)
+            m_bambu_panel->UpdateByObj(nullptr);
+        else if (m_active_child == Child::Orca && m_orca_panel)
+            m_orca_panel->UpdateByObj(nullptr);
+
+        if (target == Child::Bambu)
+            ensureBambuPanel();
+        else
+            ensureOrcaPanel();
+        showChild(target);
+    }
+
+    if (target == Child::Bambu)
+        ensureBambuPanel()->UpdateByObj(obj);
+    else if (target == Child::Orca)
+        ensureOrcaPanel()->UpdateByObj(obj);
+}
+
+void StoragePanel::SwitchStorage(bool external)
+{
+    if (m_bambu_panel)
+        m_bambu_panel->SwitchStorage(external);
+}
+
+void StoragePanel::Rescale()
+{
+    if (m_bambu_panel)
+        m_bambu_panel->Rescale();
+    if (m_orca_panel)
+        m_orca_panel->Rescale();
+}
+
+void StoragePanel::on_sys_color_changed()
+{
+    const wxColour light_background("#EEEEEE");
+    SetBackgroundColour(wxGetApp().dark_mode() ? StateColor::darkModeColorFor(light_background) : light_background);
+    if (m_bambu_panel)
+        wxGetApp().UpdateDarkUIWin(m_bambu_panel);
+    if (m_orca_panel)
+        wxGetApp().UpdateDarkUIWin(m_orca_panel);
+    if (m_orca_panel)
+        m_orca_panel->on_sys_color_changed();
+    Refresh();
+}
+
+}}

src/slic3r/GUI/StoragePanel.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <wx/panel.h>
+
+namespace Slic3r {
+class MachineObject;
+
+namespace GUI {
+
+class MediaFilePanel;
+class OrcaFilesPanel;
+
+class StoragePanel : public wxPanel
+{
+public:
+    explicit StoragePanel(wxWindow* parent);
+
+    void UpdateByObj(MachineObject* obj);
+    void SwitchStorage(bool external);
+    void Rescale();
+    void on_sys_color_changed();
+
+private:
+    enum class Child { None, Bambu, Orca };
+
+    MediaFilePanel* ensureBambuPanel();
+    OrcaFilesPanel* ensureOrcaPanel();
+    void showChild(Child child);
+
+    MediaFilePanel* m_bambu_panel = nullptr;
+    OrcaFilesPanel* m_orca_panel = nullptr;
+    Child m_active_child = Child::None;
+};
+
+}}

src/slic3r/GUI/SyncAmsInfoDialog.cpp

@@ -1421,6 +1421,12 @@ bool SyncAmsInfoDialog::get_ams_mapping_result(std::string &mapping_array_str, s
             BOOST_LOG_TRIVIAL(error) << "get_ams_mapping_result, plater is nullptr";
         }
 
+        // mapping_v1_json is built one entry per filament preset, in preset order, so the
+        // array position is the logical filament index the generated G-code toolchange
+        // references (the identifier handed to the Klipper toolchange macro; see
+        // OrcaPrinterAgent::build_filament_mapping and the index-correlation test in
+        // tests/slic3rutils/test_orca_printer_agent.cpp). Never re-densify after dropping
+        // sentinel entries, or a used filament would be aimed at the wrong lane.
         for (int i = 0; i < wxGetApp().preset_bundle->filament_presets.size(); i++) {
             int  tray_id = -1;
             json mapping_item_v1;

src/slic3r/GUI/Widgets/AMSItem.cpp

@@ -99,6 +99,7 @@ bool AMSinfo::parse_ams_info(MachineObject *obj, DevAms *ams, bool remain_flag,
         Caninfo info;
         // tray is exists
         if (it != ams->GetTrays().end() && it->second->is_exists) {
+            info.is_empty = it->second->is_empty;
             if (it->second->is_tray_info_ready()) {
                 info.can_id        = it->second->id;
                 info.ctype         = it->second->ctype;
@@ -166,6 +167,7 @@ void AMSinfo::parse_ext_info(MachineObject* obj, DevAmsTray tray) {
     this->ams_type = AMSModel::EXT_AMS;
     Caninfo info;
     info.can_id = std::to_string(0);
+    info.is_empty = tray.is_empty;
     this->cans.clear();
 
     if (tray.id == std::to_string(VIRTUAL_TRAY_MAIN_ID))
@@ -1128,9 +1130,9 @@ void AMSLib::render_lite_text(wxDC& dc)
     dc.SetTextForeground(temp_text_colour);
 
     auto libsize = GetSize();
-    if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND
+    if (!m_info.is_empty && (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND
         || m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND
-        || m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL) {
+        || m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL)) {
 
         if (m_info.material_name.empty()) {
             auto tsize = dc.GetMultiLineTextExtent("?");
@@ -1178,7 +1180,7 @@ void AMSLib::render_lite_text(wxDC& dc)
         }
     }
 
-    if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY) {
+    if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY || m_info.is_empty) {
         auto tsize = dc.GetMultiLineTextExtent(_L("/"));
         auto pot = wxPoint((libsize.x - tsize.x) / 2 + FromDIP(2), (libsize.y - tsize.y) / 2 + FromDIP(3));
         dc.DrawText(_L("/"), pot);
@@ -1187,8 +1189,12 @@ void AMSLib::render_lite_text(wxDC& dc)
 
 void AMSLib::render_generic_text(wxDC &dc)
 {
-    bool show_k_value = true;
-    if (m_info.material_name.empty()) {
+    // K/N is Bambu firmware's flow-dynamics calibration; agents with no printer-side
+    // records (OrcaSonar, Moonraker) must not show a synthesized value.
+    const bool k_supported = !m_obj || m_obj->supports_extrusion_cali();
+    const bool show_kn = m_show_kn && k_supported;
+    bool show_k_value = k_supported;
+    if (!k_supported || m_info.material_name.empty()) {
         show_k_value = false;
     }
     else if (m_info.cali_idx == -1 || (m_obj && (CalibUtils::get_selected_calib_idx(m_obj->pa_calib_tab, m_info.cali_idx) == -1))) {
@@ -1229,9 +1235,9 @@ void AMSLib::render_generic_text(wxDC &dc)
     }
 
     auto libsize = GetSize();
-    if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND
+    if (!m_info.is_empty && (m_info.material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND
         || m_info.material_state == AMSCanType::AMS_CAN_TYPE_BRAND
-        || m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL) {
+        || m_info.material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL)) {
 
         if (m_info.material_name.empty() /*&&  m_info.material_state != AMSCanType::AMS_CAN_TYPE_VIRTUAL*/) {
             auto tsize = dc.GetMultiLineTextExtent("?");
@@ -1269,7 +1275,7 @@ void AMSLib::render_generic_text(wxDC &dc)
                 auto line_top_tsize = dc.GetMultiLineTextExtent(line_top);
                 auto line_bottom_tsize = dc.GetMultiLineTextExtent(line_bottom);
 
-                if (!m_show_kn) {
+                if (!show_kn) {
                     auto pot_top = wxPoint((libsize.x - line_top_tsize.x) / 2, (libsize.y - line_top_tsize.y) / 2 - line_top_tsize.y + FromDIP(6));
                     dc.DrawText(line_top, pot_top);
 
@@ -1300,7 +1306,7 @@ void AMSLib::render_generic_text(wxDC &dc)
 
         //draw k&n
         if (m_obj && show_k_value) {
-            if (m_show_kn) {
+            if (show_kn) {
                 wxString str_k = wxString::Format("K %1.3f", m_info.k);
                 wxString str_n = wxString::Format("N %1.3f", m_info.n);
                 dc.SetFont(::Label::Body_11);
@@ -1311,7 +1317,7 @@ void AMSLib::render_generic_text(wxDC &dc)
         }
     }
 
-    if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY) {
+    if (m_info.material_state == AMSCanType::AMS_CAN_TYPE_EMPTY || m_info.is_empty) {
         auto tsize = dc.GetMultiLineTextExtent(_L("Empty"));
         auto pot = wxPoint((libsize.x - tsize.x) / 2, (libsize.y - tsize.y) / 2 + FromDIP(3));
         dc.DrawText(_L("Empty"), pot);
@@ -2808,7 +2814,7 @@ void AMSPreview::doRender(wxDC &dc)
                 }
                 else {
                     wxRect rect(left, (size.y - AMS_ITEM_CUBE_SIZE.y) / 2, AMS_ITEM_CUBE_SIZE.x, AMS_ITEM_CUBE_SIZE.y);
-                    if (iter->material_state == AMSCanType::AMS_CAN_TYPE_EMPTY) {
+                    if (iter->material_state == AMSCanType::AMS_CAN_TYPE_EMPTY || iter->is_empty) {
                         dc.SetPen(wxPen(wxColor(0, 0, 0)));
                         dc.DrawLine(rect.GetRight() - FromDIP(1), rect.GetTop() + FromDIP(1), rect.GetLeft() + FromDIP(1), rect.GetBottom() - FromDIP(1));
                     }

src/slic3r/GUI/Widgets/AMSItem.hpp

@@ -200,6 +200,7 @@ struct Caninfo
     wxString        material_name;
     wxColour        material_colour = {*wxWHITE};
     AMSCanType      material_state;
+    bool            is_empty = false;
     int             ctype=0;
     int             material_remain = 100;
     int             cali_idx = -1;
@@ -215,6 +216,7 @@ public:
             material_name == other.material_name &&
             material_colour == other.material_colour &&
             material_state == other.material_state &&
+            is_empty == other.is_empty &&
             ctype == other.ctype &&
             material_remain == other.material_remain &&
             cali_idx == other.cali_idx &&

src/slic3r/Utils/BBLPrinterAgent.cpp

@@ -203,9 +203,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;
@@ -215,9 +214,8 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
     }
 
     double value = input_val;
-    if (!is_core_xy && (axis == "Y" || axis == "Z")) {
-        value = -1.0 * input_val;
-    }
+    if (!is_core_xy && (axis == "Y" || axis == "Z"))
+        value = -input_val;
 
     std::string value_str = (boost::format("%.1f") % (value * unit)).str();
     std::string gcode;
@@ -238,11 +236,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;
 }
 
@@ -588,15 +585,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)
 {
-    int result = dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
+    return dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
         BBLNetworkPlugin::instance().get_start_send_gcode_to_sdcard(), params, update_fn, cancel_fn, wait_fn);
-    if (result != 0) {
-        BOOST_LOG_TRIVIAL(error) << "start_send_gcode_to_sdcard failed: result=" << result
-            << ", try_emmc_print=" << params.try_emmc_print
-            << ", legacy_mode=" << BBLNetworkPlugin::instance().use_legacy_network()
-            << ", dev_ip=" << params.dev_ip << ", dev_id=" << params.dev_id;
-    }
-    return result;
 }
 
 int BBLPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)

src/slic3r/Utils/BBLPrinterAgent.hpp

@@ -109,7 +109,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

@@ -289,11 +289,8 @@ bool CrealityPrintAgent::parse_cfs_response(const std::string&    response,
     return true;
 }
 
-bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    if (sync_mode != get_filament_sync_mode())
-        return false;
-
     if (device_info.dev_ip.empty()) {
         BOOST_LOG_TRIVIAL(warning)
             << "CrealityPrintAgent::fetch_filament_info: no device IP, falling back to base agent";

src/slic3r/Utils/Http.cpp

@@ -31,8 +31,19 @@
 #include <curl/curl.h>
 #include <utility>
 
-#ifdef OPENSSL_CERT_OVERRIDE
+#include <openssl/err.h>
+#include <openssl/ssl.h>
 #include <openssl/x509.h>
+#include <openssl/x509err.h>
+
+#ifdef _WIN32
+#    ifndef NOMINMAX
+#        define NOMINMAX
+#    endif
+#    include <windows.h>
+#    include <wincrypt.h>
+// wincrypt.h uses this token for a certificate-name property identifier.
+#    undef X509_NAME
 #endif
 
 namespace fs = boost::filesystem;
@@ -956,6 +967,45 @@ std::string Http::tls_system_cert_store()
     return ret;
 }
 
+void Http::add_platform_root_certificates(SSL_CTX* ssl_context)
+{
+#ifdef _WIN32
+    X509_STORE* openssl_store = SSL_CTX_get_cert_store(ssl_context);
+    if (!openssl_store)
+        throw std::runtime_error("unable to get OpenSSL certificate store");
+
+    const auto load_store = [&](DWORD location) {
+        HCERTSTORE windows_store = CertOpenStore(CERT_STORE_PROV_SYSTEM_W, 0, 0,
+                                                 location | CERT_STORE_OPEN_EXISTING_FLAG | CERT_STORE_READONLY_FLAG,
+                                                 L"ROOT");
+        if (!windows_store)
+            return;
+
+        PCCERT_CONTEXT windows_certificate = nullptr;
+        while ((windows_certificate = CertEnumCertificatesInStore(windows_store, windows_certificate)) != nullptr) {
+            const unsigned char* encoded = windows_certificate->pbCertEncoded;
+            X509* certificate = d2i_X509(nullptr, &encoded, static_cast<long>(windows_certificate->cbCertEncoded));
+            if (!certificate) {
+                ERR_clear_error();
+                continue;
+            }
+
+            ERR_clear_error();
+            if (X509_STORE_add_cert(openssl_store, certificate) != 1)
+                ERR_clear_error();
+            X509_free(certificate);
+        }
+
+        CertCloseStore(windows_store, 0);
+    };
+
+    load_store(CERT_SYSTEM_STORE_CURRENT_USER);
+    load_store(CERT_SYSTEM_STORE_LOCAL_MACHINE);
+#else
+    (void)ssl_context;
+#endif
+}
+
 std::string Http::url_encode(const std::string &str)
 {
 	::CURL *curl = ::curl_easy_init();

src/slic3r/Utils/Http.hpp

@@ -13,6 +13,8 @@
 #include "libslic3r/Exception.hpp"
 #include "libslic3r_version.h"
 
+typedef struct ssl_ctx_st SSL_CTX;
+
 #define MAX_SIZE_TO_FILE    3*1024
 
 namespace Slic3r {
@@ -200,6 +202,10 @@ public:
     // Return empty string on success or error message on fail.
     static std::string tls_global_init();
     static std::string tls_system_cert_store();
+    // Add platform root certificates to a standalone OpenSSL context. This
+    // supplements set_default_verify_paths() on platforms where OpenSSL does
+    // not use the native certificate store.
+    static void add_platform_root_certificates(SSL_CTX* ssl_context);
 
 	// converts the given string to an url_encoded_string
 	static std::string url_encode(const std::string &str);

src/slic3r/Utils/IPrinterAgent.hpp

@@ -13,6 +13,7 @@
 #include <memory>
 #include <vector>
 #include <functional>
+#include <cstdint>
 #include <cmath>
 #include <nlohmann/json.hpp>
 #include <boost/format.hpp>
@@ -68,6 +69,34 @@ enum class CameraStreamMode {
     http_snapshot // HTTP endpoint returning one image per request
 };
 
+struct PrinterFileEntry {
+    std::string   path;      // gcodes-root-relative, e.g. "sub/foo.gcode"
+    std::string   name;      // basename for display
+    std::uint64_t size = 0;  // bytes
+    std::int64_t  modified = 0; // unix seconds
+};
+
+// Moonraker per-file metadata: print time and filament usage. Missing fields are 0.
+struct PrinterFileMetadata {
+    int    estimated_time = 0;   // seconds
+    double filament_total = 0;   // millimetres
+    double filament_weight = 0;  // grams
+};
+
+// Async listing of the printer's G-code files. The return value reports whether
+// the request was dispatched; `callback` is invoked once with the result.
+using PrinterFileListFn = std::function<void(int result, std::vector<PrinterFileEntry> files)>;
+
+// Async fetch of one G-code file's embedded thumbnail. `image` is the raw image
+// bytes (empty when the file has no thumbnail); result reports dispatch/transfer.
+using PrinterFileThumbnailFn = std::function<void(int result, std::string image)>;
+
+// Async deletion of one printer G-code file. `result` reports dispatch and outcome.
+using PrinterFileDeleteFn = std::function<void(int result)>;
+
+// Async fetch of one G-code file's Moonraker metadata. `meta` fields default to 0.
+using PrinterFileMetadataFn = std::function<void(int result, PrinterFileMetadata meta)>;
+
 /**
  * IPrinterAgent - Interface for printer operations.
  *
@@ -109,6 +138,16 @@ public:
      */
     virtual int send_message(std::string dev_id, std::string json_str, int qos, int flag) = 0;
 
+    // Capability queries are per-device because one agent may own many printers.
+    // Legacy agents keep their existing behavior unless they override these.
+    virtual bool supports_command(const std::string& /*dev_id*/, const std::string& /*command*/) const { return true; }
+    virtual bool supports_feature(const std::string& /*dev_id*/, const std::string& /*feature*/) const { return false; }
+
+    // Whether this agent serializes AMS lane selection into print.gcode_file's
+    // per-print filament_mapping field. A dialect question, not a capability one:
+    // the no-AMS external-spool normalization runs before capabilities are known.
+    virtual bool uses_filament_mapping() const { return false; }
+
     // why: gcode is firmware dialect, not a waist concept - commands whose body is Bambu-dialect
     // gcode live on the agent that speaks it; the default is an honest refusal that MachineObject's
     // publish funnel turns into a dialog.
@@ -316,6 +355,48 @@ public:
         return -1;
     }
 
+    /**
+     * List the printer's G-code files, delivered asynchronously via callback.
+     * Agents without a file listing report ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.
+     */
+    virtual int list_printer_files(const std::string& dev_id, PrinterFileListFn callback)
+    {
+        (void) dev_id;
+        (void) callback;
+        return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED;
+    }
+
+    /**
+     * Fetch one G-code file's embedded thumbnail, delivered asynchronously via
+     * callback. Agents without thumbnail support report ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.
+     */
+    virtual int get_printer_file_thumbnail(const std::string& dev_id, const std::string& path, PrinterFileThumbnailFn callback)
+    {
+        (void) dev_id; (void) path; (void) callback;
+        return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED;
+    }
+
+    /**
+     * Delete one G-code file from the printer, delivered asynchronously via
+     * callback. Agents without file deletion report ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.
+     */
+    virtual int delete_printer_file(const std::string& dev_id, const std::string& path, PrinterFileDeleteFn callback)
+    {
+        (void) dev_id; (void) path; (void) callback;
+        return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED;
+    }
+
+    /**
+     * Fetch one G-code file's Moonraker metadata (print time and filament usage),
+     * delivered asynchronously via callback. Agents without metadata support
+     * report ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.
+     */
+    virtual int get_printer_file_metadata(const std::string& dev_id, const std::string& path, PrinterFileMetadataFn callback)
+    {
+        (void) dev_id; (void) path; (void) callback;
+        return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED;
+    }
+
     /**
      * Register callback for fatal HTTP errors.
      */

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -13,49 +13,12 @@
 #include <set>
 #include <string>
 #include <thread>
-#include <chrono>
-#include <condition_variable>
-#include <deque>
-#include <functional>
 
 #include <nlohmann/json.hpp>
 #include <vector>
 
 namespace Slic3r {
 
-class Http;
-
-bool moonraker_is_light_name(const std::string& name);
-
-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:
@@ -101,20 +64,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;
+
+    // Pull-mode agent (on-demand filament sync)
+    FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::pull; }
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
-    CameraStreamMode get_camera_stream_mode() const override;
-    std::string get_camera_url() const override;
 
 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;
@@ -126,9 +81,7 @@ protected:
         std::string dev_name;
         std::string version;
         std::string klippy_state;
-        float       nozzle_diameter = 0.0f;
         bool        use_ssl = false;
-        std::string ca_file;
     } device_info;
 
     // Tray data for AMS payload building
@@ -146,21 +99,12 @@ protected:
     void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
 
     // Methods that derived classes may need to override or access
-    virtual bool init_device_info(const PrinterConnectionParams& params);
-    virtual bool fetch_device_info(const ConnectionSettings& connection, MoonrakerDeviceInfo& info, std::string& error) const;
-    ConnectionSettings get_connection_settings() const;
-    void configure_http(Http& http, const ConnectionSettings& connection) const;
-    static float parse_nozzle_diameter(const nlohmann::json& response);
+    virtual bool init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port);
+    virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
 
     // State access for derived classes
     mutable std::recursive_mutex       state_mutex;
 
-    // Counts detached fetch_filament_info() background threads currently touching `this`
-    // (see QidiPrinterAgent::fetch_filament_info). Those threads hold a raw `this` with no
-    // other lifetime protection, so the destructor waits for this to reach 0 before any part
-    // of the object is torn down — see ~MoonrakerPrinterAgent().
-    std::atomic<int> filament_fetch_in_flight{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);
@@ -173,29 +117,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);
-
 private:
     int handle_request(const std::string& dev_id, const std::string& json_str);
     int send_version_info(const std::string& dev_id);
     int send_access_code(const std::string& dev_id);
 
-    bool fetch_object_list(const ConnectionSettings& connection, std::set<std::string>& objects, std::string& error) const;
-    bool query_printer_status(const ConnectionSettings& connection, nlohmann::json& status, std::string& error) const;
+    bool fetch_object_list(const std::string& base_url, const std::string& api_key, std::set<std::string>& objects, std::string& error) const;
+    bool query_printer_status(const std::string& base_url, const std::string& api_key, nlohmann::json& status, std::string& error) const;
     bool send_gcode_sync(const std::string& dev_id, const std::string& gcode) const;
     void send_gcode_async(const std::string& dev_id, const std::string& gcode,
                           std::function<void(bool)> on_result = {}) const;
@@ -204,11 +132,10 @@ private:
     void dispatch_local_connect(int state, const std::string& dev_id, const std::string& msg);
     void dispatch_printer_connected(const std::string& dev_id);
     void dispatch_message(const std::string& dev_id, const std::string& payload);
-    void start_status_stream(const std::string& dev_id, ConnectionSettings connection);
+    void start_status_stream(const std::string& dev_id, const std::string& base_url, const std::string& api_key);
     void stop_status_stream();
-    void run_status_stream(std::string dev_id, ConnectionSettings connection);
-    void handle_ws_message(std::string dev_id, std::string payload, ConnectionSettings connection);
-    void refresh_thumbnail_url(const ConnectionSettings& connection);
+    void run_status_stream(std::string dev_id, std::string base_url, std::string api_key);
+    void handle_ws_message(const std::string& dev_id, const std::string& payload);
     void update_status_cache(const nlohmann::json& updates);
     nlohmann::json build_print_payload_locked() const;
 
@@ -219,28 +146,22 @@ private:
 
     // 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);
 
-    // Start a print of a previously uploaded G-code file (path relative to the
-    // Moonraker gcodes root).
-    bool start_print_file(const ConnectionSettings& connection,
-                          const std::string& filename, std::string& error_msg) const;
+    // JSON-RPC helper
+    bool send_jsonrpc_command(const std::string& base_url, const std::string& api_key,
+                              const nlohmann::json& request, std::string& response) const;
 
     // Connection thread management
     void perform_connection_async(const std::string& dev_id,
-                                   ConnectionSettings connection,
+                                   const std::string& base_url,
+                                   const std::string& api_key,
                                    uint64_t generation);
 
-    // why: a printer with no /server/webcams/list entry can still name its stream directly;
-    // subclasses (e.g. printers with a fixed webcam path) can override this instead.
-    virtual std::string webcam_stream_override(const std::string& base_url) const { return {}; }
-    void refresh_webcam_info() const;
-    bool fetch_webcam_info(const ConnectionSettings& connection, uint64_t generation) const;
-
     // System-specific filament fetch methods
-    bool fetch_hh_filament_info(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
-    bool fetch_moonraker_filament_data(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_hh_filament_info(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_moonraker_filament_data(std::vector<AmsTrayData>& trays, int& max_lane_index);
 
     // JSON helper methods
     static std::string safe_json_string(const nlohmann::json& obj, const char* key);
@@ -266,38 +187,15 @@ private:
 
     mutable std::recursive_mutex payload_mutex;
     nlohmann::json     status_cache;
-    // note: guarded by payload_mutex; filled by refresh_thumbnail_url(), empty url = looked up, none found
-    std::string        thumbnail_filename;
-    std::string        thumbnail_url;
-    mutable std::string        webcam_stream_url;
-    mutable CameraStreamMode   webcam_stream_mode = CameraStreamMode::none;
-    mutable uint64_t            webcam_info_last_lookup_ms = 0;
-    mutable uint64_t            webcam_info_generation = 0;
-    unsigned            thumbnail_lookup_attempts = 0;
-
-    static constexpr uint64_t WEBCAM_INFO_REFRESH_INTERVAL_MS = 1000;
 
     std::atomic<int>       next_jsonrpc_id{1};
     std::set<std::string>  available_objects;  // Track for feature detection
-    bool                   assumed_light_on = false;
 
     std::atomic<bool>   ws_stop{false};
     std::atomic<bool>   ws_reconnect_requested{false};  // Flag to trigger reconnection
     std::atomic<uint64_t> ws_last_emit_ms{0};
     std::thread         ws_thread;
 
-    // stop_status_stream() invokes ws_abort_io to wake a blocked synchronous
-    // ws.read()/ws.write()/handshake in run_status_stream(): ws_stop is only
-    // observed between reads, and Beast's expires_after() does not bound
-    // synchronous operations.
-    std::mutex             ws_abort_mutex;
-    std::function<void()>  ws_abort_io;  // guarded by ws_abort_mutex
-
-    // AMS/filament refresh cadence, independent of telemetry dispatch so a steady
-    // stream of status updates can't starve it (ws_last_emit_ms is reset by those).
-    static constexpr uint64_t AMS_REFRESH_INTERVAL_MS = 10000;
-    std::atomic<uint64_t> ams_last_fetch_ms{0};
-
     // Throttling configuration for WebSocket updates
     // Critical changes (state transitions) dispatch immediately; telemetry is throttled
     static constexpr uint64_t STATUS_UPDATE_INTERVAL_MS = 1000;  // 1 update/sec for telemetry
@@ -307,14 +205,7 @@ private:
     // Connection thread management
     std::atomic<uint64_t>  connect_generation{0};
     std::thread            connect_thread;
-    mutable 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;
+    std::recursive_mutex   connect_mutex;
 };
 
 } // namespace Slic3r

src/slic3r/Utils/NetworkAgent.cpp

@@ -806,6 +806,36 @@ int NetworkAgent::send_message(std::string dev_id, std::string json_str, int qos
     return -1;
 }
 
+bool NetworkAgent::owns_agent(const std::string& expected_agent_id) const
+{
+    if (!m_printer_agent)
+        return false;
+    return expected_agent_id.empty() || m_printer_agent->get_agent_info().id == expected_agent_id;
+}
+
+bool NetworkAgent::supports_command(const std::string& expected_agent_id, const std::string& dev_id,
+                                   const std::string& command) const
+{
+    if (!owns_agent(expected_agent_id))
+        return false;
+    return m_printer_agent->supports_command(dev_id, command);
+}
+
+bool NetworkAgent::supports_feature(const std::string& expected_agent_id, const std::string& dev_id,
+                                   const std::string& feature) const
+{
+    if (!owns_agent(expected_agent_id))
+        return false;
+    return m_printer_agent->supports_feature(dev_id, feature);
+}
+
+bool NetworkAgent::uses_filament_mapping(const std::string& expected_agent_id) const
+{
+    if (!owns_agent(expected_agent_id))
+        return false;
+    return m_printer_agent->uses_filament_mapping();
+}
+
 int NetworkAgent::command_ams_refresh_rfid(std::string dev_id, int ams_id, int slot_id, int sequence_id, bool lan_mode)
 {
     if (m_printer_agent)
@@ -1106,4 +1136,32 @@ int NetworkAgent::get_hms_snapshot(std::string dev_id, std::string file_name, st
     return -1;
 }
 
+int NetworkAgent::list_printer_files(const std::string& dev_id, PrinterFileListFn callback)
+{
+    if (m_printer_agent)
+        return m_printer_agent->list_printer_files(dev_id, callback);
+    return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED;
+}
+
+int NetworkAgent::get_printer_file_thumbnail(const std::string& dev_id, const std::string& path, PrinterFileThumbnailFn callback)
+{
+    if (m_printer_agent)
+        return m_printer_agent->get_printer_file_thumbnail(dev_id, path, callback);
+    return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED;
+}
+
+int NetworkAgent::delete_printer_file(const std::string& dev_id, const std::string& path, PrinterFileDeleteFn callback)
+{
+    if (m_printer_agent)
+        return m_printer_agent->delete_printer_file(dev_id, path, callback);
+    return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED;
+}
+
+int NetworkAgent::get_printer_file_metadata(const std::string& dev_id, const std::string& path, PrinterFileMetadataFn callback)
+{
+    if (m_printer_agent)
+        return m_printer_agent->get_printer_file_metadata(dev_id, path, callback);
+    return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED;
+}
+
 } // namespace Slic3r

src/slic3r/Utils/NetworkAgent.hpp

@@ -153,6 +153,10 @@ public:
     int set_on_local_message_fn(OnMessageFn fn);
     int set_server_callback(OnServerErrFn fn);
     int send_message(std::string dev_id, std::string json_str, int qos, int flag);
+    bool owns_agent(const std::string& expected_agent_id) const;
+    bool supports_command(const std::string& expected_agent_id, const std::string& dev_id, const std::string& command) const;
+    bool supports_feature(const std::string& expected_agent_id, const std::string& dev_id, const std::string& feature) const;
+    bool uses_filament_mapping(const std::string& expected_agent_id) const;
     int command_ams_refresh_rfid(std::string dev_id, int ams_id, int slot_id, int sequence_id, bool lan_mode);
     int command_ams_calibrate(std::string dev_id, int ams_id, int sequence_id, bool lan_mode);
     int command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode);
@@ -194,6 +198,10 @@ public:
     std::string from_orca_filament_id(const std::string& orca_filament_id) const;
     int request_bind_ticket(std::string* ticket);
     int get_hms_snapshot(std::string dev_id, std::string file_name, std::function<void(std::string, int)> callback);
+    int list_printer_files(const std::string& dev_id, PrinterFileListFn callback);
+    int get_printer_file_thumbnail(const std::string& dev_id, const std::string& path, PrinterFileThumbnailFn callback);
+    int delete_printer_file(const std::string& dev_id, const std::string& path, PrinterFileDeleteFn callback);
+    int get_printer_file_metadata(const std::string& dev_id, const std::string& path, PrinterFileMetadataFn callback);
 
 private:
     struct PrinterCallbacks {

src/slic3r/Utils/NetworkAgentFactory.hpp

@@ -17,7 +17,7 @@
 
 namespace Slic3r {
 static constexpr char ORCA_PRINTER_AGENT_ID[] = "orca";
-static constexpr char BBL_PRINTER_AGENT_ID[] = "bbl";
+static constexpr char BBL_PRINTER_AGENT_ID[]  = "bbl";
 
 // Factory function type for creating printer agents
 using PrinterAgentFactory =
@@ -26,17 +26,20 @@ using PrinterAgentFactory =
 // Information about a registered printer agent
 struct PrinterAgentInfo
 {
-    std::string         id;           // Registry/config key, e.g. "orca" or a plugin AgentInfo::id
-    std::string         display_name; // e.g., "Orca Native", "Bambu Lab"
-    std::string         plugin_identifier;     // Empty for built-ins, otherwise <plugin_key>;<uuid>;<capability_name>
-    PrinterAgentFactory factory;      // Function to create the agent
+    std::string id;                // Registry/config key, e.g. "orca" or a plugin AgentInfo::id
+    std::string display_name;      // e.g., "Orca Native", "Bambu Lab"
+    std::string plugin_identifier; // Empty for built-ins, otherwise <plugin_key>;<uuid>;<capability_name>
+    PrinterAgentFactory factory;   // Function to create the agent
 
     bool is_plugin() const { return !plugin_identifier.empty(); }
     PrinterAgentInfo(const std::string& id_, const std::string& display_name_, PrinterAgentFactory factory_)
         : id(id_), display_name(display_name_), factory(std::move(factory_))
     {}
 
-    PrinterAgentInfo(const std::string& id_, const std::string& display_name_, const std::string& plugin_identifier, PrinterAgentFactory factory_)
+    PrinterAgentInfo(const std::string& id_,
+                     const std::string& display_name_,
+                     const std::string& plugin_identifier,
+                     PrinterAgentFactory factory_)
         : id(id_), display_name(display_name_), plugin_identifier(plugin_identifier), factory(std::move(factory_))
     {}
 };
@@ -118,9 +121,9 @@ public:
      * @param log_dir Directory for log files
      * @return Shared pointer to IPrinterAgent, or nullptr if ID not found
      */
-    static std::shared_ptr<IPrinterAgent> create_printer_agent_by_id(const std::string&                  id,
+    static std::shared_ptr<IPrinterAgent> create_printer_agent_by_id(const std::string& id,
                                                                      std::shared_ptr<ICloudServiceAgent> cloud_agent,
-                                                                     const std::string&                  log_dir);
+                                                                     const std::string& log_dir);
 
     /**
      * Clear the printer agent cache.

src/slic3r/Utils/OrcaCloudServiceAgent.cpp

@@ -1,6 +1,8 @@
 #include "OrcaCloudServiceAgent.hpp"
 #include "CloudProvider.hpp"
 #include "Http.hpp"
+#include "ICameraSignalingChannel.hpp"
+#include "OrcaCloudSignalingChannel.hpp"
 #include "bambu_networking.hpp"
 #include "ICloudServiceAgent.hpp"
 #include "libslic3r/Utils.hpp"
@@ -12,6 +14,8 @@
 #include <boost/asio/ip/tcp.hpp>
 #include <boost/asio/io_context.hpp>
 #include <boost/beast/core/detail/base64.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/beast/websocket.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/filesystem/operations.hpp>
 #include <boost/log/trivial.hpp>
@@ -37,14 +41,18 @@
 #include <openssl/hmac.h>
 #include <openssl/rand.h>
 #include <openssl/sha.h>
+#include <openssl/ssl.h>
 
 #include <algorithm>
 #include <cctype>
+#include <condition_variable>
+#include <cstdint>
 #include <cstdlib>
 #include <fstream>
 #include <iomanip>
 #include <optional>
 #include <random>
+#include <set>
 #include <sstream>
 
 #include <string>
@@ -512,6 +520,7 @@ OrcaCloudServiceAgent::OrcaCloudServiceAgent(std::string log_dir)
     , api_base_url(ORCA_DEFAULT_API_URL)
     , auth_base_url(ORCA_DEFAULT_AUTH_URL)
     , cloud_base_url(ORCA_DEFAULT_CLOUD_URL)
+    , mqtt_connection(std::make_unique<OrcaMqttConnection>())
 {
     auth_headers["apikey"]    = ORCA_DEFAULT_PUB_KEY;
     pkce_bundle.loopback_port = choose_loopback_port();
@@ -522,6 +531,8 @@ OrcaCloudServiceAgent::OrcaCloudServiceAgent(std::string log_dir)
 
 OrcaCloudServiceAgent::~OrcaCloudServiceAgent()
 {
+    if (mqtt_connection)
+        mqtt_connection->stop();
     if (refresh_thread.joinable()) {
         refresh_thread.join();
     }
@@ -964,22 +975,45 @@ bool OrcaCloudServiceAgent::ensure_token_fresh(const std::string& reason) { retu
 
 int OrcaCloudServiceAgent::connect_server()
 {
+    const bool logged_in = is_user_login();
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: OrcaCloudServiceAgent::connect_server logged_in=" << logged_in
+                            << " api_base_url=" << api_base_url;
+    if (!logged_in) {
+        if (mqtt_connection)
+            mqtt_connection->stop();
+        {
+            std::lock_guard<std::recursive_mutex> lock(state_mutex);
+            is_connected = false;
+        }
+        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: connect_server requires a logged-in user";
+        invoke_server_connected_callback(-1, 401);
+        return BAMBU_NETWORK_ERR_INVALID_HANDLE;
+    }
+
     std::string response;
     unsigned int http_code = 0;
     int result             = http_get(ORCA_HEALTH_PATH, &response, &http_code);
 
     bool connected = (result == BAMBU_NETWORK_SUCCESS && http_code >= 200 && http_code < 300);
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: cloud health result=" << result << " http_code=" << http_code
+                            << " connected=" << connected << " response_bytes=" << response.size();
+
+    // connect_server() remains a REST health probe. The long-lived fleet MQTT socket
+    // is started lazily by set_user_selected_machine -> configure_selected_printer_mqtt;
+    // subscriptions queued before that point are replayed when it starts.
     {
         std::lock_guard<std::recursive_mutex> lock(state_mutex);
         is_connected = connected;
     }
-
     invoke_server_connected_callback(connected ? 0 : -1, http_code);
     return connected ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED;
 }
 
 bool OrcaCloudServiceAgent::is_server_connected()
 {
+    // The REST health probe is the signal; the per-printer MQTT socket does not gate
+    // whole-cloud connectivity (one printer reconnecting must not report the whole
+    // cloud as lost).
     std::lock_guard<std::recursive_mutex> lock(state_mutex);
     return is_connected;
 }
@@ -1000,13 +1034,238 @@ int OrcaCloudServiceAgent::stop_subscribe(std::string module)
 
 int OrcaCloudServiceAgent::add_subscribe(std::vector<std::string> dev_list)
 {
-    (void) dev_list;
-    return BAMBU_NETWORK_SUCCESS;
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: OrcaCloudServiceAgent::add_subscribe count=" << dev_list.size()
+                            << " logged_in=" << is_user_login() << " mqtt_connection=" << (mqtt_connection ? "set" : "null");
+    if (!is_user_login() || !mqtt_connection) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: add_subscribe rejected because cloud is not ready";
+        return BAMBU_NETWORK_ERR_INVALID_HANDLE;
+    }
+    bool queued = true;
+    for (const std::string& dev_id : dev_list)
+        queued = mqtt_connection->subscribe(dev_id) && queued;
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: add_subscribe queued=" << queued;
+    return queued ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED;
 }
 
 int OrcaCloudServiceAgent::del_subscribe(std::vector<std::string> dev_list)
 {
-    (void) dev_list;
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: OrcaCloudServiceAgent::del_subscribe count=" << dev_list.size()
+                            << " logged_in=" << is_user_login() << " mqtt_connection=" << (mqtt_connection ? "set" : "null");
+    if (!is_user_login() || !mqtt_connection) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: del_subscribe rejected because cloud is not ready";
+        return BAMBU_NETWORK_ERR_INVALID_HANDLE;
+    }
+    bool queued = true;
+    for (const std::string& dev_id : dev_list)
+        queued = mqtt_connection->unsubscribe(dev_id) && queued;
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: del_subscribe queued=" << queued;
+    return queued ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED;
+}
+
+int OrcaCloudServiceAgent::configure_selected_printer_mqtt(const std::string& dev_id,
+                                                           OrcaMqttConnection::StateHandler state_handler)
+{
+    (void) dev_id;
+    if (!ensure_token_fresh("configure_selected_printer_mqtt"))
+    {
+        BOOST_LOG_TRIVIAL(warning) << "ensure_token_fresh returned false";
+        return BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED;
+    }
+
+    OrcaMqttConnection::Config cfg;
+    cfg.url               = "wss://" + api_base_url + "/api/v1/printers/mqtt";
+    cfg.use_tls           = true;
+    cfg.bearer_provider   = [this] { return get_access_token(); };
+    cfg.client_id         = "OrcaSlicer";
+    cfg.keepalive_seconds = 300;
+
+    {
+        std::lock_guard<std::mutex> lock(m_selected_url_mutex);
+        m_selected_printer_mqtt_url = cfg.url;
+    }
+
+    if (mqtt_connection->is_running()) {
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: fleet MQTT connection already running";
+        return BAMBU_NETWORK_SUCCESS;
+    }
+
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: configuring fleet MQTT endpoint=" << cfg.url;
+
+    // NOTE: no lock is held across start() — it blocks for the whole initial connect
+    // attempt (up to ~10s), and the message handler below re-enters callback_mutex on
+    // the MQTT worker thread.
+    const bool ok = mqtt_connection->start(
+        cfg,
+        [this](const std::string& id, const std::string& payload) { deliver_cloud_message(id, payload); },
+        std::move(state_handler));
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: fleet MQTT start returned=" << ok;
+    return ok ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECTION_TO_SERVER_FAILED;
+}
+
+void OrcaCloudServiceAgent::teardown_selected_printer_mqtt()
+{
+    if (mqtt_connection) {
+        mqtt_connection->stop();
+        // The connection object is reused for the next printer; drop this printer's
+        // report topic so its 1:1 socket does not re-subscribe the previous device.
+        mqtt_connection->clear_subscriptions();
+    }
+    std::lock_guard<std::mutex> lock(m_selected_url_mutex);
+    m_selected_printer_mqtt_url.clear();
+}
+
+std::string OrcaCloudServiceAgent::selected_printer_mqtt_url() const
+{
+    std::lock_guard<std::mutex> lock(m_selected_url_mutex);
+    return m_selected_printer_mqtt_url;
+}
+
+void OrcaCloudServiceAgent::deliver_cloud_message(const std::string& dev_id, const std::string& payload)
+{
+    OnMessageFn callback;
+    {
+        std::lock_guard<std::mutex> lock(callback_mutex);
+        callback = printer_status_callback;
+    }
+    if (callback)
+        callback(dev_id, payload);
+}
+
+int OrcaCloudServiceAgent::set_printer_status_callback(OnMessageFn fn)
+{
+    std::lock_guard<std::mutex> lock(callback_mutex);
+    printer_status_callback = std::move(fn);
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: printer status callback=" << (printer_status_callback ? "set" : "clear");
+    return BAMBU_NETWORK_SUCCESS;
+}
+
+int OrcaCloudServiceAgent::send_printer_command(const std::string& dev_id, const std::string& body)
+{
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: send_printer_command dev_id=" << dev_id
+                            << " body_bytes=" << body.size() << " logged_in=" << is_user_login();
+    if (dev_id.empty() || !is_user_login()) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: send_printer_command rejected";
+        return BAMBU_NETWORK_ERR_INVALID_HANDLE;
+    }
+
+    const std::string path = std::string(ORCA_CLOUD_PRINTER) + "/" + dev_id + "/commands";
+    std::string  response;
+    unsigned int http_code = 0;
+    int          result    = http_post(path, body, &response, &http_code);
+    BOOST_LOG_TRIVIAL(info) << "OrcaCloudServiceAgent: command dev=" << dev_id
+                            << " http=" << http_code << " result=" << result
+                            << " response_bytes=" << response.size();
+    return (result == BAMBU_NETWORK_SUCCESS && http_code >= 200 && http_code < 300)
+               ? BAMBU_NETWORK_SUCCESS
+               : BAMBU_NETWORK_ERR_CONNECT_FAILED;
+}
+
+int OrcaCloudServiceAgent::upload_gcode_via_cloud(const std::string& dev_id,
+                                                  const std::string& local_gcode_path,
+                                                  std::string* job_id,
+                                                  OnUpdateStatusFn update_fn,
+                                                  WasCancelledFn cancel_fn)
+{
+    if (dev_id.empty() || local_gcode_path.empty() || !is_user_login())
+        return BAMBU_NETWORK_ERR_INVALID_HANDLE;
+    if (cancel_fn && cancel_fn())
+        return BAMBU_NETWORK_ERR_CANCELED;
+
+    // Step 1: POST print-jobs/uploads -> a short-lived presigned R2 PUT URL. No
+    // metadata rides this request; filename/start are only relevant to the HTTP
+    // .../start finalize route, which this MQTT-driven flow does not call.
+    const std::string uploads_path = std::string(ORCA_CLOUD_PRINTER) + "/" + Http::url_encode(dev_id) + "/print-jobs/uploads";
+    std::string response;
+    unsigned int http_code = 0;
+    int result = http_post(uploads_path, "{}", &response, &http_code);
+    if (result != BAMBU_NETWORK_SUCCESS || http_code < 200 || http_code >= 300) {
+        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: print-jobs/uploads failed http_code=" << http_code;
+        return BAMBU_NETWORK_ERR_CONNECT_FAILED;
+    }
+
+    std::string upload_job_id;
+    std::string upload_url;
+    try {
+        const nlohmann::json j = nlohmann::json::parse(response);
+        upload_job_id = j.value("job_id", "");
+        upload_url    = j.value("upload_url", "");
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: failed to parse print-jobs/uploads response: " << e.what();
+        return BAMBU_NETWORK_ERR_CONNECT_FAILED;
+    }
+    if (upload_job_id.empty() || upload_url.empty()) {
+        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: print-jobs/uploads response missing job_id/upload_url";
+        return BAMBU_NETWORK_ERR_CONNECT_FAILED;
+    }
+
+    if (cancel_fn && cancel_fn())
+        return BAMBU_NETWORK_ERR_CANCELED;
+
+    // Step 2: PUT the G-code straight to R2 with the one-time URL from step 1. This
+    // is a scoped, PUT-only, short-TTL capability with no bearer token of its own,
+    // so it bypasses http_put (which always prefixes api_base_url and attaches the
+    // cloud session's Authorization header - neither belongs on an R2 PUT).
+    bool canceled = false;
+    unsigned put_status = 0;
+    std::string put_error;
+    Http::put(upload_url)
+        .tls_verify(true)
+        .header("Content-Type", "text/x.gcode")
+        .set_put_body(boost::filesystem::path(local_gcode_path))
+        .timeout_connect(5)
+        .timeout_max(300) // large G-code over a slow link
+        .on_progress([&](Http::Progress progress, bool& cancel) {
+            if (cancel_fn && cancel_fn()) {
+                cancel   = true;
+                canceled = true;
+                return;
+            }
+            if (update_fn && progress.ultotal > 0) {
+                const int percent = static_cast<int>((progress.ulnow * 100) / progress.ultotal);
+                update_fn(PrintingStageUpload, percent, "Uploading...");
+            }
+        })
+        .on_complete([&](std::string, unsigned status) { put_status = status; })
+        .on_error([&](std::string, std::string err, unsigned status) {
+            put_status = status;
+            put_error  = std::move(err);
+        })
+        .perform_sync();
+
+    if (canceled)
+        return BAMBU_NETWORK_ERR_CANCELED;
+    if (put_status < 200 || put_status >= 300) {
+        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: R2 upload failed status=" << put_status << " error=" << put_error;
+        return BAMBU_NETWORK_ERR_PRINT_SG_UPLOAD_FTP_FAILED;
+    }
+
+    if (job_id)
+        *job_id = std::move(upload_job_id);
+    return BAMBU_NETWORK_SUCCESS;
+}
+
+int OrcaCloudServiceAgent::start_cloud_print_job(const std::string& dev_id,
+                                                 const std::string& job_id,
+                                                 const std::string& filename,
+                                                 bool start)
+{
+    if (dev_id.empty() || job_id.empty() || !is_user_login())
+        return BAMBU_NETWORK_ERR_INVALID_HANDLE;
+
+    nlohmann::json body;
+    if (!filename.empty())
+        body["filename"] = filename;
+    body["start"] = start;
+
+    const std::string path = std::string(ORCA_CLOUD_PRINTER) + "/" + Http::url_encode(dev_id) + "/print-jobs/" +
+                             Http::url_encode(job_id) + "/start";
+    std::string response;
+    unsigned int http_code = 0;
+    const int result = http_post(path, body.dump(), &response, &http_code);
+    if (result != BAMBU_NETWORK_SUCCESS || http_code < 200 || http_code >= 300) {
+        BOOST_LOG_TRIVIAL(warning) << "OrcaCloudServiceAgent: print-jobs/" << job_id << "/start failed http_code=" << http_code;
+        return BAMBU_NETWORK_ERR_CONNECT_FAILED;
+    }
     return BAMBU_NETWORK_SUCCESS;
 }
 
@@ -2041,6 +2300,10 @@ bool OrcaCloudServiceAgent::set_user_session(const json& session_json, bool noti
 
 void OrcaCloudServiceAgent::clear_session(bool all_backends)
 {
+    if (mqtt_connection) {
+        mqtt_connection->stop();
+        mqtt_connection->clear_subscriptions();
+    }
     {
         std::lock_guard<std::mutex> lock(session_mutex);
         session = SessionInfo{};
@@ -2156,7 +2419,11 @@ int OrcaCloudServiceAgent::http_get(const std::string& path, std::string* respon
     return (res.success && !suppress) ? BAMBU_NETWORK_SUCCESS : BAMBU_NETWORK_ERR_CONNECT_FAILED;
 }
 
-int OrcaCloudServiceAgent::http_post(const std::string& path, const std::string& body, std::string* response_body, unsigned int* http_code)
+int OrcaCloudServiceAgent::http_post(const std::string& path,
+                                     const std::string& body,
+                                     std::string* response_body,
+                                     unsigned int* http_code,
+                                     const std::string& content_type)
 {
     std::string url = api_base_url + path;
     BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: POST " << url;
@@ -2180,7 +2447,7 @@ int OrcaCloudServiceAgent::http_post(const std::string& path, const std::string&
                 http.header("Authorization", "Bearer " + token);
             }
 
-            http.header("Content-Type", "application/json");
+            http.header("Content-Type", content_type);
             http.set_post_body(body);
 
             http.on_complete([&](std::string resp_body, unsigned resp_status) {
@@ -2647,19 +2914,28 @@ int OrcaCloudServiceAgent::get_user_print_info(unsigned int* http_code, std::str
     if (http_code)
         *http_code = code;
 
-    if (result != 0 || code != 200)
+    if (result != 0 || code != 200) {
+        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: get_user_print_info failed - http_code=" << code << ", response=" << response;
         return result != 0 ? result : BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED;
+    }
+
+    BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: get_user_print_info fetched - http_code=" << code << ", response=" << response;
 
     try {
         auto resp_json = nlohmann::json::parse(response);
         nlohmann::json devices = nlohmann::json::array();
 
         for (const auto& printer : resp_json.value("data", nlohmann::json::array())) {
-            const std::string role = printer.value("access_role", "");
+            nlohmann::json device;
+            std::string role = printer.value("access_role", "");
+
+            // A printer with the role "view" only has monitoring access for orca cloud.
+            // The printer is owned by a different person and was shared to the current user without
+            // any permission to control the printer so we discard this printer. Comment this out if
+            // OrcaSlicer wants to support view only printers.
             if (role.empty() || role == "viewer")
                 continue;
 
-            nlohmann::json device;
             device["dev_id"]   = printer.value("id", "");
             device["dev_name"] = printer.value("name", "");
             if (printer.contains("model") && printer["model"].is_string())
@@ -2673,15 +2949,20 @@ int OrcaCloudServiceAgent::get_user_print_info(unsigned int* http_code, std::str
                     device["task_status"] = status["job"].value("state", "");
             }
             device["dev_online"] = online;
-            devices.push_back(std::move(device));
+
+            devices.push_back(device);
         }
 
         if (http_body) {
             nlohmann::json out;
-            out["devices"] = std::move(devices);
+            out["devices"] = devices;
             *http_body = out.dump();
         }
-    } catch (const std::exception&) {
+
+        BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_user_print_info parsed - device_count=" << devices.size()
+                                  << ", devices=" << devices.dump();
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: get_user_print_info parse exception - " << e.what();
         return BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED;
     }
 
@@ -2766,6 +3047,9 @@ int OrcaCloudServiceAgent::get_camera_url(std::string dev_id, std::function<void
     return BAMBU_NETWORK_SUCCESS;
 }
 
+std::unique_ptr<ICameraSignalingChannel> OrcaCloudServiceAgent::create_camera_signaling_channel(const std::string& dev_id)
+{ return std::make_unique<OrcaCloudSignalingChannel>(this, dev_id); }
+
 int OrcaCloudServiceAgent::get_design_staffpick(int offset, int limit, std::function<void(std::string)> callback)
 {
     BOOST_LOG_TRIVIAL(debug) << "OrcaCloudServiceAgent: get_design_staffpick (stub)";

src/slic3r/Utils/OrcaCloudServiceAgent.hpp

@@ -4,6 +4,11 @@
 #include "CloudProvider.hpp"
 #include "ICameraSignalingChannel.hpp"
 #include "ICloudServiceAgent.hpp"
+#include <boost/asio.hpp>
+#include <boost/asio/ssl.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/beast/ssl.hpp>
+#include <boost/beast/websocket.hpp>
 #include "bambu_networking.hpp"
 #include <cstdlib>
 #include "libslic3r/ProjectTask.hpp"
@@ -13,6 +18,9 @@
 #include <atomic>
 #include <chrono>
 #include <functional>
+#include <condition_variable>
+#include <cstdint>
+#include <set>
 #include <memory>
 #include <thread>
 #include <unordered_map>
@@ -20,6 +28,8 @@
 #include <vector>
 #include <nlohmann/json.hpp>
 
+#include "OrcaMqttConnection.hpp"
+
 class wxSecretStore;
 
 namespace Slic3r {
@@ -156,6 +166,8 @@ public:
 
     // Configuration
     void configure_urls(AppConfig* app_config);
+    // Hostname only; cloud REST, MQTT, and WebRTC signaling use fixed TLS
+    // endpoints on port 443.
     void set_api_base_url(const std::string& url);
     void set_auth_base_url(const std::string& url);
     void set_cloud_base_url(const std::string& url);
@@ -211,6 +223,19 @@ public:
     int add_subscribe(std::vector<std::string> dev_list) override;
     int del_subscribe(std::vector<std::string> dev_list) override;
     void enable_multi_machine(bool enable) override;
+    int set_printer_status_callback(OnMessageFn fn);
+    int send_printer_command(const std::string& dev_id, const std::string& body);
+
+    int upload_gcode_via_cloud(const std::string& dev_id,
+                               const std::string& local_gcode_path,
+                               std::string* job_id,
+                               OnUpdateStatusFn update_fn,
+                               WasCancelledFn cancel_fn);
+
+    int start_cloud_print_job(const std::string& dev_id,
+                              const std::string& job_id,
+                              const std::string& filename,
+                              bool start = true);
 
     // ========================================================================
     // ICloudServiceAgent Interface Implementation - Settings Synchronization
@@ -246,7 +271,7 @@ public:
     // ICloudServiceAgent Interface Implementation - Model Mall & Publishing
     // ========================================================================
     int get_camera_url(std::string dev_id, std::function<void(std::string)> callback) override;
-    // std::unique_ptr<ICameraSignalingChannel> create_camera_signaling_channel(const std::string& dev_id) override;
+    std::unique_ptr<ICameraSignalingChannel> create_camera_signaling_channel(const std::string& dev_id) override;
     int get_design_staffpick(int offset, int limit, std::function<void(std::string)> callback) override;
     int start_publish(PublishParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, std::string* out) override;
     int get_model_publish_url(std::string* url) override;
@@ -352,7 +377,29 @@ public:
 
     static std::string generate_uuid_for_setting_id(const std::string& name, const std::string& user_id = "");
 
+    OrcaMqttConnection* get_mqtt_connection() noexcept {
+        return mqtt_connection.get();
+    }
+
+    const OrcaMqttConnection* get_mqtt_connection() const noexcept {
+        return mqtt_connection.get();
+    }
+
+    // Account-scoped cloud socket: wss://<api_base_url>/api/v1/printers/mqtt.
+    // configure_ blocks for the duration of the initial connect attempt, so callers
+    // drive it off the UI thread; teardown_ is synchronous. The dev_id argument is
+    // retained for source compatibility with the printer-agent lifecycle; it does
+    // not participate in endpoint construction.
+    int         configure_selected_printer_mqtt(const std::string& dev_id,
+                                                OrcaMqttConnection::StateHandler state_handler = {});
+    void        teardown_selected_printer_mqtt();
+    // Test hook: the wss:// URL of the current fleet socket ("" when none).
+    std::string selected_printer_mqtt_url() const;
+
 private:
+    // Fans one inbound fleet MQTT message out to printer_status_callback.
+    void deliver_cloud_message(const std::string& dev_id, const std::string& payload);
+
     // Sync protocol helpers
     int sync_pull(
         std::function<void(const SyncPullResponse&)> on_success,
@@ -376,7 +423,11 @@ private:
 
     // HTTP request helpers
     int http_get(const std::string& path, std::string* response_body, unsigned int* http_code);
-    int http_post(const std::string& path, const std::string& body, std::string* response_body, unsigned int* http_code);
+    int http_post(const std::string& path,
+                  const std::string& body,
+                  std::string* response_body,
+                  unsigned int* http_code,
+                  const std::string& content_type = "application/json");
     int http_put(const std::string& path, const std::string& body, std::string* response_body, unsigned int* http_code);
     int http_delete(const std::string& path, std::string* response_body, unsigned int* http_code);
     std::map<std::string, std::string> data_headers();
@@ -434,6 +485,9 @@ private:
                                std::chrono::system_clock::now().time_since_epoch()).count()};
 
     // Member variables - connection state
+    std::unique_ptr<OrcaMqttConnection> mqtt_connection;
+    std::string        m_selected_printer_mqtt_url;   // guarded by m_selected_url_mutex
+    mutable std::mutex m_selected_url_mutex;
     bool is_connected{false};
     bool enable_track{false};
     bool multi_machine_enabled{false};
@@ -447,6 +501,7 @@ private:
     AppOnHttpErrorFn on_http_error_fn;
     GetCountryCodeFn get_country_code_fn;
     QueueOnMainFn queue_on_main_fn;
+    OnMessageFn printer_status_callback;
     mutable std::mutex callback_mutex;
 
     // Thread safety

src/slic3r/Utils/OrcaCloudSignalingChannel.cpp

@@ -0,0 +1,337 @@
+#include "OrcaCloudSignalingChannel.hpp"
+
+#include "Http.hpp"
+
+#include <boost/asio/connect.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/post.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/log/trivial.hpp>
+#include <nlohmann/json.hpp>
+
+#include <openssl/ssl.h>
+
+#include <cctype>
+#include <iomanip>
+#include <sstream>
+#include <stdexcept>
+
+namespace Slic3r {
+
+OrcaCloudSignalingChannel::OrcaCloudSignalingChannel(OrcaCloudServiceAgent* cloud, std::string dev_id)
+    : m_cloud(cloud)
+    , m_dev_id(std::move(dev_id))
+{
+}
+
+OrcaCloudSignalingChannel::~OrcaCloudSignalingChannel()
+{
+    close();
+}
+
+void OrcaCloudSignalingChannel::open()
+{
+    bool expected = false;
+    if (!m_open.compare_exchange_strong(expected, true))
+        return;
+    m_stop.store(false);
+    m_thread = std::thread([this] { run(); });
+}
+
+void OrcaCloudSignalingChannel::close()
+{
+    m_stop.store(true);
+    std::shared_ptr<Connection> conn;
+    Http::Ptr request;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        conn = m_conn;
+        request = m_inflight_requests;
+    }
+    // m_conn is installed only after the live-token request completes, so
+    // cancel the request independently before waiting for the worker.
+    if (request)
+        request->cancel();
+    if (conn) {
+        // Established session: close the socket on the io_context's own thread so
+        // the pending async_read completes and io_context.run() unwinds.
+        boost::asio::post(conn->io_context, [conn] {
+            boost::system::error_code ec;
+            boost::beast::get_lowest_layer(conn->websocket).cancel(ec);
+            boost::beast::get_lowest_layer(conn->websocket).close(ec);
+        });
+        // Pre-run() phase (still in the synchronous connect/handshake): best-effort
+        // direct interruption.
+        boost::system::error_code ec;
+        boost::beast::get_lowest_layer(conn->websocket).cancel(ec);
+        boost::beast::get_lowest_layer(conn->websocket).close(ec);
+    }
+    if (m_thread.joinable())
+        m_thread.join();
+    m_open.store(false);
+}
+
+void OrcaCloudSignalingChannel::send_offer(std::string sdp)
+{
+    send_json(nlohmann::json{{"type", "webrtc.offer"}, {"sdp", std::move(sdp)}}.dump());
+}
+
+void OrcaCloudSignalingChannel::send_ice(std::string candidate, std::string mid)
+{
+    send_json(nlohmann::json{{"type", "webrtc.ice"},
+                             {"candidate", std::move(candidate)},
+                             {"sdpMid", std::move(mid)}}
+                  .dump());
+}
+
+std::string OrcaCloudSignalingChannel::encode_path_component(const std::string& value)
+{
+    std::ostringstream encoded;
+    encoded << std::uppercase << std::hex;
+    for (unsigned char c : value) {
+        if (std::isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~')
+            encoded << c;
+        else
+            encoded << '%' << std::setw(2) << std::setfill('0') << static_cast<unsigned int>(c);
+    }
+    return encoded.str();
+}
+
+void OrcaCloudSignalingChannel::unavailable(CameraUnavailableReason reason, std::string detail)
+{
+    if (on_unavailable)
+        on_unavailable(reason, std::move(detail));
+}
+
+void OrcaCloudSignalingChannel::run()
+{
+    try {
+        if (!m_cloud || !m_cloud->ensure_token_fresh("camera")) {
+            unavailable(CameraUnavailableReason::Error, "Unable to refresh OrcaCloud credentials");
+            m_open.store(false);
+            return;
+        }
+        const std::string token = m_cloud->get_access_token();
+        // OrcaCloud exposes a bare API hostname. WebRTC signaling uses the
+        // fixed HTTPS/WSS endpoints on port 443; custom schemes, ports, and
+        // base paths are not supported by this agent.
+        const std::string host = m_cloud->get_cloud_service_host();
+        if (token.empty() || host.empty()) {
+            unavailable(CameraUnavailableReason::Error, "OrcaCloud session is unavailable");
+            m_open.store(false);
+            return;
+        }
+
+        const std::string live_token_url =
+            "https://" + host + "/api/v1/printers/" + encode_path_component(m_dev_id) + "/live-token";
+        BOOST_LOG_TRIVIAL(info) << "signaling: POST " << live_token_url << " (dev_id=" << m_dev_id << ")";
+
+        nlohmann::json token_response;
+        std::string token_body;
+        unsigned int http_code = 0;
+
+        auto request = std::make_shared<Slic3r::Http>(Http::post(live_token_url));
+        request->set_post_body(std::string("{}"))
+            .header("Authorization", "Bearer " + token)
+            .header("Content-Type", "application/json")
+            .tls_verify(true)
+            .timeout_max(30)
+            .on_complete([&token_body, &http_code](std::string body, unsigned status) {
+                http_code = status;
+                token_body = std::move(body);
+            })
+            .on_error([&http_code](std::string, std::string, unsigned status) {
+                http_code = status;
+            });
+
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            m_inflight_requests = request;
+        }
+
+        // If close() raced with request setup, make sure this request is
+        // cancelled before entering the blocking call.
+        if (m_stop.load())
+            request->cancel();
+        try {
+            request->perform_sync();
+        } catch (...) {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            if (m_inflight_requests == request)
+                m_inflight_requests.reset();
+            throw;
+        }
+
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            if (m_inflight_requests == request)
+                m_inflight_requests.reset();
+        }
+
+        try {
+            token_response = nlohmann::json::parse(token_body);
+        } catch (const std::exception&) {
+        }
+        if (http_code < 200 || http_code >= 300 || !token_response.contains("token")) {
+            unavailable(CameraUnavailableReason::Error, "Unable to mint camera live token");
+            m_open.store(false);
+            return;
+        }
+
+        std::vector<CameraIceServer> ice_servers;
+        if (token_response.contains("ice_servers") && token_response["ice_servers"].is_array()) {
+            for (const auto& entry : token_response["ice_servers"]) {
+                if (entry.is_string()) {
+                    ice_servers.push_back({entry.get<std::string>(), {}, {}});
+                } else if (entry.is_object()) {
+                    // RTCIceServer.urls is "string | string[]" (Cloudflare
+                    // Realtime returns an array). Emit one CameraIceServer per
+                    // URL, sharing the credentials.
+                    const std::string username = entry.value("username", std::string{});
+                    const std::string credential = entry.value("credential", std::string{});
+                    const auto add_url = [&](const nlohmann::json& url) {
+                        if (url.is_string() && !url.get<std::string>().empty())
+                            ice_servers.push_back({url.get<std::string>(), username, credential});
+                    };
+                    const auto urls = entry.find("urls");
+                    if (urls != entry.end()) {
+                        if (urls->is_array()) {
+                            for (const auto& url : *urls)
+                                add_url(url);
+                        } else {
+                            add_url(*urls);
+                        }
+                    }
+                }
+            }
+        }
+        auto conn = std::make_shared<Connection>();
+        conn->ssl_context.set_default_verify_paths();
+        Http::add_platform_root_certificates(conn->ssl_context.native_handle());
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            m_conn = conn;
+        }
+        auto& websocket = conn->websocket;
+        boost::asio::ip::tcp::resolver resolver(conn->io_context);
+        const auto endpoints = resolver.resolve(host, "443");
+        boost::asio::connect(boost::beast::get_lowest_layer(websocket), endpoints);
+        if (!SSL_set_tlsext_host_name(websocket.next_layer().native_handle(), host.c_str()))
+            throw std::runtime_error("Unable to configure TLS server name");
+        websocket.next_layer().set_verify_mode(boost::asio::ssl::verify_peer);
+        websocket.next_layer().set_verify_callback(boost::asio::ssl::host_name_verification(host));
+        websocket.next_layer().handshake(boost::asio::ssl::stream_base::client);
+        const std::string ws_target = "/api/v1/printers/" + encode_path_component(m_dev_id) +
+                                      "/camera/live?token=" +
+                                      encode_path_component(token_response["token"].get<std::string>());
+        websocket.handshake(host, ws_target);
+        BOOST_LOG_TRIVIAL(info) << "signaling: websocket handshake ok (" << ice_servers.size()
+                                << " ice servers)";
+
+        if (on_ready)
+            on_ready(std::move(ice_servers));
+        send_json(nlohmann::json{{"type", "camera.mode"}, {"mode", "webrtc"}}.dump());
+        // Async read loop, driven by the connection's own io_context. run()
+        // returns once close() has shut the socket down, giving a bounded,
+        // deadlock-free teardown from any thread.
+        do_read(conn);
+        conn->io_context.run();
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "signaling: run() exception: " << e.what();
+        if (!m_stop.load())
+            unavailable(CameraUnavailableReason::Closed, e.what());
+    }
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_conn.reset();
+    }
+    m_open.store(false);
+}
+
+void OrcaCloudSignalingChannel::do_read(std::shared_ptr<Connection> conn)
+{
+    auto buffer = std::make_shared<boost::beast::flat_buffer>();
+    conn->websocket.async_read(
+        *buffer, [this, conn, buffer](boost::system::error_code ec, std::size_t) {
+            if (ec) {
+                if (!m_stop.load())
+                    unavailable(CameraUnavailableReason::Closed, ec.message());
+                return; // do not re-arm; io_context.run() unwinds
+            }
+            const std::string raw = boost::beast::buffers_to_string(buffer->data());
+            // A malformed or unexpectedly-shaped message must not tear down the
+            // session: parse/dispatch is guarded.
+            try {
+                dispatch_message(nlohmann::json::parse(raw), raw);
+            } catch (const std::exception& e) {
+                BOOST_LOG_TRIVIAL(warning) << "signaling: ignoring malformed message: " << e.what()
+                                           << " raw=" << raw.substr(0, 256);
+            }
+            if (!m_stop.load())
+                do_read(conn);
+        });
+}
+
+// Returns the string at key, or "" if absent or not a string (JSON null included).
+static std::string json_string(const nlohmann::json& object, const char* key)
+{
+    const auto it = object.find(key);
+    return (it != object.end() && it->is_string()) ? it->get<std::string>() : std::string{};
+}
+
+void OrcaCloudSignalingChannel::dispatch_message(const nlohmann::json& message, const std::string& raw)
+{
+    const std::string type = json_string(message, "type");
+    BOOST_LOG_TRIVIAL(info) << "signaling: recv type=" << type << " raw=" << raw.substr(0, 256);
+    if (type == "webrtc.answer") {
+        const std::string sdp = json_string(message, "sdp");
+        if (on_answer && !sdp.empty())
+            on_answer(sdp);
+    } else if (type == "webrtc.ice" && message.contains("candidate")) {
+        // The peer may send "candidate" as a flat string or as a nested
+        // RTCIceCandidateInit object { candidate, sdpMid, sdpMLineIndex }.
+        const nlohmann::json& candidate = message["candidate"];
+        std::string sdp_candidate;
+        std::string mid = json_string(message, "sdpMid");
+        if (candidate.is_string()) {
+            sdp_candidate = candidate.get<std::string>();
+        } else if (candidate.is_object()) {
+            sdp_candidate = json_string(candidate, "candidate");
+            std::string nested_mid = json_string(candidate, "sdpMid");
+            if (!nested_mid.empty())
+                mid = std::move(nested_mid);
+        }
+        if (on_ice && !sdp_candidate.empty())
+            on_ice(sdp_candidate, mid);
+    } else if (type == "webrtc.unavailable") {
+        const std::string reason = json_string(message, "reason");
+        unavailable(reason == "busy" ? CameraUnavailableReason::Busy
+                                     : reason == "disabled" ? CameraUnavailableReason::Disabled
+                                                            : CameraUnavailableReason::Error,
+                    reason.empty() ? "error" : reason);
+    }
+}
+
+void OrcaCloudSignalingChannel::send_json(const std::string& message)
+{
+    std::shared_ptr<Connection> conn;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        conn = m_conn;
+    }
+    if (!conn || m_stop.load())
+        return;
+    // Serialize the write onto the io_context thread (same thread that runs
+    // async_read), so reads and writes never touch the stream concurrently.
+    auto payload = std::make_shared<std::string>(message);
+    boost::asio::post(conn->io_context, [this, conn, payload] {
+        if (m_stop.load())
+            return;
+        boost::system::error_code ec;
+        conn->websocket.write(boost::asio::buffer(*payload), ec);
+        if (ec && !m_stop.load())
+            unavailable(CameraUnavailableReason::Closed, ec.message());
+    });
+}
+
+} // namespace Slic3r

src/slic3r/Utils/OrcaCloudSignalingChannel.hpp

@@ -0,0 +1,66 @@
+#pragma once
+
+#include "ICameraSignalingChannel.hpp"
+#include "OrcaCloudServiceAgent.hpp"
+#include "Http.hpp"
+
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/ssl.hpp>
+#include <boost/beast/ssl.hpp>
+#include <boost/beast/websocket.hpp>
+
+#include <nlohmann/json_fwd.hpp>
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+
+namespace Slic3r {
+
+class OrcaCloudSignalingChannel : public ICameraSignalingChannel {
+public:
+    OrcaCloudSignalingChannel(OrcaCloudServiceAgent* cloud, std::string dev_id);
+    ~OrcaCloudSignalingChannel() override;
+
+    void open() override;
+    void close() override;
+    void send_offer(std::string sdp) override;
+    void send_ice(std::string candidate, std::string mid) override;
+
+private:
+    using WebSocket = boost::beast::websocket::stream<
+        boost::beast::ssl_stream<boost::asio::ip::tcp::socket>>;
+
+    // The io_context and ssl_context must outlive the websocket stream that
+    // references them. Bundling them here with the stream declared last makes
+    // the destruction order correct (stream first, then contexts), and lets a
+    // single shared_ptr own the whole set.
+    struct Connection {
+        boost::asio::io_context io_context;
+        boost::asio::ssl::context ssl_context{boost::asio::ssl::context::tls_client};
+        WebSocket websocket{io_context, ssl_context};
+    };
+
+    void run();
+    void do_read(std::shared_ptr<Connection> conn);
+    void dispatch_message(const nlohmann::json& message, const std::string& raw);
+    void send_json(const std::string& message);
+    void unavailable(CameraUnavailableReason reason, std::string detail);
+    static std::string encode_path_component(const std::string& value);
+
+    OrcaCloudServiceAgent* m_cloud;
+
+    Http::Ptr m_inflight_requests{nullptr};
+
+    std::string m_dev_id;
+    std::atomic<bool> m_stop{false};
+    std::atomic<bool> m_open{false};
+    std::thread m_thread;
+    mutable std::mutex m_mutex;
+    std::shared_ptr<Connection> m_conn;
+};
+
+} // namespace Slic3r

src/slic3r/Utils/OrcaMqttConnection.cpp

@@ -0,0 +1,805 @@
+#include "OrcaMqttConnection.hpp"
+#include "Http.hpp"
+
+#include <boost/asio.hpp>
+#include <boost/asio/ssl.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/beast/ssl.hpp>
+#include <boost/beast/websocket.hpp>
+
+#include <openssl/ssl.h>
+
+#include <algorithm>
+#include <chrono>
+#include <memory>
+#include <optional>
+#include <sstream>
+#include <stdexcept>
+#include <utility>
+
+namespace Slic3r {
+
+struct OrcaMqttConnection::Connection {
+    boost::asio::io_context io_context;
+    boost::asio::ssl::context ssl_context;
+    boost::asio::ip::tcp::resolver resolver;
+    boost::asio::steady_timer keepalive_timer;
+    boost::beast::flat_buffer read_buffer;
+    std::deque<std::shared_ptr<std::vector<uint8_t>>> outbound_packets;
+    boost::system::error_code terminal_error;
+    std::atomic_bool async_session_started{false};
+    bool write_in_progress{false};
+    // Exactly one of these is engaged once ws_handshake() has run: wss for
+    // wss:// endpoints, ws for plaintext ws://.
+    std::optional<TlsWebSocket>   wss;
+    std::optional<PlainWebSocket> ws;
+
+    Connection()
+        : ssl_context(boost::asio::ssl::context::tls_client)
+        , resolver(io_context)
+        , keepalive_timer(io_context)
+    {}
+};
+
+namespace {
+// Apply / clear a tcp_stream timeout on whichever websocket is engaged.
+// Templated on the connection type only because Connection is a private nested
+// type: a deduced parameter needs no (inaccessible) name for it.
+template<class Conn> void expires_after(Conn& conn, std::chrono::seconds timeout) {
+    if (conn.wss)     boost::beast::get_lowest_layer(*conn.wss).expires_after(timeout);
+    else if (conn.ws) boost::beast::get_lowest_layer(*conn.ws).expires_after(timeout);
+}
+template<class Conn> void expires_never(Conn& conn) {
+    if (conn.wss)     boost::beast::get_lowest_layer(*conn.wss).expires_never();
+    else if (conn.ws) boost::beast::get_lowest_layer(*conn.ws).expires_never();
+}
+} // namespace
+
+OrcaMqttConnection::~OrcaMqttConnection() { stop(); }
+
+bool OrcaMqttConnection::start(const Config& config, MessageHandler on_message, StateHandler on_state) {
+    std::lock_guard<std::recursive_mutex> lifecycle_lock(lifecycle_mutex);
+    stop();
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        current_config    = config;
+        this->on_message  = std::move(on_message);
+        this->on_state    = std::move(on_state);
+        initial_result    = false;
+        initial_completed = false;
+        connected         = false;
+        m_last_connack_rc.store(-1);
+    }
+    stopping.store(false);
+    worker = std::thread(&OrcaMqttConnection::run, this);
+
+    std::unique_lock<std::mutex> lock(mutex);
+    if (!initial_cv.wait_for(lock, std::chrono::seconds(10), [this] { return initial_completed; })) {
+        initial_completed = true;
+        initial_result    = false;
+    }
+    return initial_result;
+}
+
+void OrcaMqttConnection::stop() {
+    std::lock_guard<std::recursive_mutex> lifecycle_lock(lifecycle_mutex);
+    stopping.store(true);
+    state_cv.notify_all();
+    {
+        std::lock_guard<std::mutex> lock(connection_mutex);
+        if (active_connection) {
+            if (active_connection->async_session_started.load()) {
+                // The worker owns the live WebSocket. Stop dispatching its
+                // asynchronous operations; the worker closes the socket after
+                // leaving the event loop.
+                active_connection->io_context.stop();
+            } else {
+                // Setup still uses synchronous operations on the worker. Wake a
+                // pending resolve/connect/CONNACK read without competing with a
+                // live asynchronous session.
+                auto shutdown_socket = [](auto& websocket) {
+                    auto& socket = boost::beast::get_lowest_layer(websocket).socket();
+                    boost::system::error_code socket_error;
+                    if (socket.cancel(socket_error))
+                        return;
+                    if (socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, socket_error))
+                        return;
+                    if (socket.close(socket_error))
+                        return;
+                };
+                if (active_connection->wss)
+                    shutdown_socket(*active_connection->wss);
+                else if (active_connection->ws)
+                    shutdown_socket(*active_connection->ws);
+                active_connection->resolver.cancel();
+            }
+        }
+    }
+    if (worker.joinable())
+        worker.join();
+
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        connected = false;
+        acknowledged_subscriptions.clear();
+        pending_subscribe_packets.clear();
+        pending_requests.clear();
+        if (!initial_completed) {
+            initial_completed = true;
+            initial_result    = false;
+        }
+    }
+    initial_cv.notify_all();
+}
+
+bool OrcaMqttConnection::is_running() const {
+    return worker.joinable() && !stopping.load();
+}
+
+void OrcaMqttConnection::flush_subscription_change() {
+    std::shared_ptr<Connection> conn;
+    {
+        std::lock_guard<std::mutex> lock(connection_mutex);
+        conn = active_connection;
+    }
+    bool connacked;
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        connacked = connected;
+    }
+    if (!conn || !connacked)
+        return; // no live MQTT session yet — the worker sends the set on CONNACK
+    boost::asio::post(conn->io_context, [this, conn] {
+        if (!stopping.load() && connected.load())
+            send_pending_subscriptions(conn);
+    });
+}
+
+bool OrcaMqttConnection::subscribe(const std::string& dev_id) {
+    if (dev_id.empty()) {
+        return false;
+    }
+    const std::string topic = report_topic(dev_id);
+    if (topic.size() > 96) { // MQTT topic filter cap enforced by the service
+        return false;
+    }
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        if (subscriptions.count(topic) != 0 && pending_unsubscriptions.count(topic) == 0) {
+            return true;
+        }
+        subscriptions.insert(topic);
+        pending_unsubscriptions.erase(topic);
+        pending_subscriptions.insert(topic);
+    }
+    state_cv.notify_all();
+    flush_subscription_change(); // ask the worker to emit SUBSCRIBE now (no reconnect)
+    return true;
+}
+
+bool OrcaMqttConnection::unsubscribe(const std::string& dev_id) {
+    const std::string topic = report_topic(dev_id);
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        subscriptions.erase(topic);
+        acknowledged_subscriptions.erase(topic);
+        pending_subscriptions.erase(topic);
+        pending_unsubscriptions.insert(topic);
+        for (auto it = pending_subscribe_packets.begin(); it != pending_subscribe_packets.end();) {
+            if (it->second == topic)
+                it = pending_subscribe_packets.erase(it);
+            else
+                ++it;
+        }
+        for (auto it = pending_requests.begin(); it != pending_requests.end();) {
+            if (it->first == dev_id)
+                it = pending_requests.erase(it);
+            else
+                ++it;
+        }
+    }
+    state_cv.notify_all();
+    flush_subscription_change(); // ask the worker to emit UNSUBSCRIBE now (no reconnect)
+    return true;
+}
+
+void OrcaMqttConnection::clear_subscriptions() {
+    std::lock_guard<std::mutex> lock(mutex);
+    subscriptions.clear();
+    pending_subscriptions.clear();
+    pending_unsubscriptions.clear();
+    acknowledged_subscriptions.clear();
+    pending_subscribe_packets.clear();
+    pending_requests.clear();
+}
+
+bool OrcaMqttConnection::parse_endpoint(const std::string& url, Endpoint& endpoint) {
+    std::string rest;
+    std::string default_port;
+    if      (url.rfind("wss://", 0) == 0) { rest = url.substr(6); default_port = "443"; }
+    else if (url.rfind("ws://",  0) == 0) { rest = url.substr(5); default_port = "80";  }
+    else return false;
+
+    const auto slash = rest.find('/');
+    const std::string authority = rest.substr(0, slash);
+    endpoint.target = (slash == std::string::npos) ? "/" : rest.substr(slash);
+
+    // host[:port] — leave an unbracketed IPv6 literal alone
+    const auto colon = authority.rfind(':');
+    if (colon != std::string::npos && authority.find(']') == std::string::npos) {
+        endpoint.host = authority.substr(0, colon);
+        endpoint.port = authority.substr(colon + 1);
+    } else {
+        endpoint.host = authority;
+        endpoint.port = default_port;
+    }
+    return !endpoint.host.empty() && !endpoint.port.empty() && !endpoint.target.empty();
+}
+
+void OrcaMqttConnection::append_string(std::vector<uint8_t>& packet, const std::string& value) {
+    if (value.size() > 0xffff)
+        throw std::runtime_error("MQTT string is too long");
+    packet.push_back(static_cast<uint8_t>(value.size() >> 8));
+    packet.push_back(static_cast<uint8_t>(value.size() & 0xff));
+    packet.insert(packet.end(), value.begin(), value.end());
+}
+
+void OrcaMqttConnection::prepend_remaining_length(std::vector<uint8_t>& packet, size_t length) {
+    std::vector<uint8_t> encoded;
+    do {
+        uint8_t byte = static_cast<uint8_t>(length % 128);
+        length /= 128;
+        if (length != 0)
+            byte |= 0x80;
+        encoded.push_back(byte);
+    } while (length != 0);
+    packet.insert(packet.begin() + 1, encoded.begin(), encoded.end());
+}
+
+std::vector<uint8_t> OrcaMqttConnection::make_connect_packet(
+    const std::string& client_id, const std::string& username,
+    const std::string& password, int keepalive_seconds) {
+    std::vector<uint8_t> packet{0x10};
+    append_string(packet, "MQTT");
+    packet.push_back(4); // protocol level 3.1.1
+
+    uint8_t flags = 0x02; // clean session
+    if (!username.empty()) { flags |= 0x80; if (!password.empty()) flags |= 0x40; }
+    packet.push_back(flags);
+
+    packet.push_back(static_cast<uint8_t>(keepalive_seconds >> 8));
+    packet.push_back(static_cast<uint8_t>(keepalive_seconds & 0xff));
+
+    append_string(packet, client_id.empty() ? "OrcaSlicer" : client_id);
+    if (!username.empty()) {
+        append_string(packet, username);
+        if (!password.empty()) append_string(packet, password);
+    }
+    prepend_remaining_length(packet, packet.size() - 1);
+    return packet;
+}
+
+std::string OrcaMqttConnection::report_topic(const std::string& device_id) { return "device/" + device_id + "/report"; }
+
+std::string OrcaMqttConnection::request_topic(const std::string& id) { return "device/" + id + "/request"; }
+
+std::vector<uint8_t> OrcaMqttConnection::make_publish_packet(const std::string& topic, const std::string& payload) {
+    std::vector<uint8_t> packet{0x30}; // PUBLISH, QoS 0, no retain
+    append_string(packet, topic);      // no packet id at QoS 0
+    packet.insert(packet.end(), payload.begin(), payload.end());
+    prepend_remaining_length(packet, packet.size() - 1);
+    return packet;
+}
+
+std::vector<uint8_t> OrcaMqttConnection::make_subscribe_packet(uint16_t id, const std::string& topic, uint8_t qos) {
+    std::vector<uint8_t> packet{0x82};
+    packet.push_back(id >> 8); packet.push_back(id & 0xff);
+    append_string(packet, topic);
+    packet.push_back(qos);
+    prepend_remaining_length(packet, packet.size() - 1);
+    return packet;
+}
+
+std::vector<uint8_t> OrcaMqttConnection::make_unsubscribe_packet(uint16_t id, const std::string& topic) {
+    std::vector<uint8_t> packet{0xA2};
+    packet.push_back(id >> 8); packet.push_back(id & 0xff);
+    append_string(packet, topic);
+    prepend_remaining_length(packet, packet.size() - 1);
+    return packet;
+}
+
+std::vector<uint8_t> OrcaMqttConnection::make_ping_packet() { return {0xc0, 0}; }
+
+void OrcaMqttConnection::ws_write(Connection& conn, const std::vector<uint8_t>& packet) {
+    if (packet.empty()) {
+        return;
+    }
+    if (conn.wss) {
+        conn.wss->binary(true);
+        conn.wss->write(boost::asio::buffer(packet));
+    } else if (conn.ws) {
+        conn.ws->binary(true);
+        conn.ws->write(boost::asio::buffer(packet));
+    }
+}
+
+void OrcaMqttConnection::close_connection(Connection& conn) {
+    boost::system::error_code error;
+    if (conn.wss) {
+        auto& socket = boost::beast::get_lowest_layer(*conn.wss).socket();
+        if (socket.cancel(error))
+            return;
+        if (socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, error))
+            return;
+        if (socket.close(error))
+            return;
+    } else if (conn.ws) {
+        auto& socket = boost::beast::get_lowest_layer(*conn.ws).socket();
+        if (socket.cancel(error))
+            return;
+        if (socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, error))
+            return;
+        if (socket.close(error))
+            return;
+    }
+}
+
+void OrcaMqttConnection::enqueue_packet(const std::shared_ptr<Connection>& conn,
+                                        std::vector<uint8_t> packet) {
+    if (!conn || packet.empty())
+        return;
+    conn->outbound_packets.emplace_back(std::make_shared<std::vector<uint8_t>>(std::move(packet)));
+    start_async_write(conn);
+}
+
+void OrcaMqttConnection::start_async_write(const std::shared_ptr<Connection>& conn) {
+    if (!conn || conn->write_in_progress || conn->outbound_packets.empty() || stopping.load())
+        return;
+
+    conn->write_in_progress = true;
+    const auto packet = conn->outbound_packets.front();
+    auto on_write = [this, conn](const boost::system::error_code& error, std::size_t) {
+        conn->write_in_progress = false;
+        if (error) {
+            if (!stopping.load())
+                conn->terminal_error = error;
+            conn->io_context.stop();
+            return;
+        }
+        conn->outbound_packets.pop_front();
+        start_async_write(conn);
+    };
+    if (conn->wss) {
+        conn->wss->binary(true);
+        conn->wss->async_write(boost::asio::buffer(*packet), std::move(on_write));
+    } else if (conn->ws) {
+        conn->ws->binary(true);
+        conn->ws->async_write(boost::asio::buffer(*packet), std::move(on_write));
+    } else {
+        conn->write_in_progress = false;
+        conn->outbound_packets.pop_front();
+    }
+}
+
+void OrcaMqttConnection::start_async_read(const std::shared_ptr<Connection>& conn) {
+    if (!conn || stopping.load())
+        return;
+
+    auto on_read = [this, conn](const boost::system::error_code& error, std::size_t) {
+        if (error) {
+            if (!stopping.load())
+                conn->terminal_error = error;
+            conn->io_context.stop();
+            return;
+        }
+        const std::string packet = boost::beast::buffers_to_string(conn->read_buffer.data());
+        conn->read_buffer.consume(conn->read_buffer.size());
+        handle_packet(packet);
+        start_async_read(conn);
+    };
+    if (conn->wss)
+        conn->wss->async_read(conn->read_buffer, std::move(on_read));
+    else if (conn->ws)
+        conn->ws->async_read(conn->read_buffer, std::move(on_read));
+}
+
+void OrcaMqttConnection::schedule_keepalive(const std::shared_ptr<Connection>& conn) {
+    const int keepalive = current_config.keepalive_seconds;
+    if (!conn || keepalive <= 0 || stopping.load())
+        return;
+
+    conn->keepalive_timer.expires_after(std::chrono::seconds(std::max(1, keepalive / 2)));
+    conn->keepalive_timer.async_wait([this, conn](const boost::system::error_code& error) {
+        if (error || stopping.load())
+            return;
+        enqueue_packet(conn, make_ping_packet());
+        schedule_keepalive(conn);
+    });
+}
+
+void OrcaMqttConnection::post_packet(const std::shared_ptr<Connection>& conn,
+                                     std::vector<uint8_t> packet) {
+    if (!conn || packet.empty())
+        return;
+    boost::asio::post(conn->io_context, [this, conn, packet = std::move(packet)]() mutable {
+        if (!stopping.load())
+            enqueue_packet(conn, std::move(packet));
+    });
+}
+
+std::size_t OrcaMqttConnection::ws_read(Connection& conn, boost::beast::flat_buffer& buffer,
+                                        boost::system::error_code& ec) {
+    if (conn.wss)
+        return conn.wss->read(buffer, ec);
+    if (conn.ws)
+        return conn.ws->read(buffer, ec);
+    ec = boost::asio::error::not_connected;
+    return 0;
+}
+
+void OrcaMqttConnection::ws_handshake(Connection& conn, const Config& config, const Endpoint& endpoint) {
+    const auto results = conn.resolver.resolve(endpoint.host, endpoint.port);
+
+    std::string token;
+    if (config.bearer_provider) {
+        token = config.bearer_provider();
+    }
+    auto decorator = [token](boost::beast::websocket::request_type& request) {
+        request.set(boost::beast::http::field::user_agent, "OrcaSlicer");
+        if (!token.empty())
+            request.set(boost::beast::http::field::authorization, "Bearer " + token);
+        request.set("Sec-WebSocket-Protocol", "mqtt");
+    };
+    boost::beast::http::response<boost::beast::http::string_body> response;
+    boost::system::error_code handshake_error;
+
+    if (config.use_tls) {
+        // stop() inspects the engaged optional under connection_mutex; publish it
+        // under the same lock, then release before the blocking connect.
+        {
+            std::lock_guard<std::mutex> lock(connection_mutex);
+            conn.wss.emplace(conn.io_context, conn.ssl_context);
+        }
+        auto& websocket = *conn.wss;
+        auto& stream    = boost::beast::get_lowest_layer(websocket);
+        stream.expires_after(std::chrono::seconds(10));
+        stream.connect(results);
+        // Set SNI before the TLS handshake so the cloud edge selects the correct
+        // certificate.
+        auto& tls_stream = websocket.next_layer();
+        if (!SSL_set_tlsext_host_name(tls_stream.native_handle(), endpoint.host.c_str()))
+            throw std::runtime_error("failed to set Orca Cloud TLS server name");
+        if (!config.ca_file.empty())
+            conn.ssl_context.load_verify_file(config.ca_file);
+        else
+            conn.ssl_context.set_default_verify_paths();
+        Http::add_platform_root_certificates(conn.ssl_context.native_handle());
+        tls_stream.set_verify_mode(boost::asio::ssl::verify_peer);
+        tls_stream.set_verify_callback(boost::asio::ssl::host_name_verification(endpoint.host));
+        tls_stream.handshake(boost::asio::ssl::stream_base::client);
+        websocket.set_option(boost::beast::websocket::stream_base::decorator(decorator));
+        websocket.handshake(response, endpoint.host, endpoint.target, handshake_error);
+    } else {
+        {
+            std::lock_guard<std::mutex> lock(connection_mutex);
+            conn.ws.emplace(conn.io_context);
+        }
+        auto& websocket = *conn.ws;
+        auto& stream    = boost::beast::get_lowest_layer(websocket);
+        stream.expires_after(std::chrono::seconds(10));
+        stream.connect(results);
+        websocket.set_option(boost::beast::websocket::stream_base::decorator(decorator));
+        websocket.handshake(response, endpoint.host, endpoint.target, handshake_error);
+    }
+
+    if (handshake_error) {
+        throw boost::system::system_error(handshake_error, "Orca WebSocket handshake");
+    }
+    if (response["Sec-WebSocket-Protocol"] != "mqtt") {
+        throw std::runtime_error("Orca WebSocket did not negotiate MQTT");
+    }
+}
+
+bool OrcaMqttConnection::send_request(const std::string& dev_id, const std::string& payload) {
+    if (dev_id.empty()) {
+        return false;
+    }
+    if (!connected.load()) {
+        return false;
+    }
+    std::shared_ptr<Connection> conn;
+    {
+        std::lock_guard<std::mutex> lock(connection_mutex);
+        conn = active_connection;
+    }
+    if (!conn) {
+        return false;
+    }
+    const std::string report = report_topic(dev_id);
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        if (subscriptions.count(report) != 0 && acknowledged_subscriptions.count(report) == 0) {
+            pending_requests.emplace_back(dev_id, payload);
+            return true;
+        }
+    }
+    post_packet(conn, make_publish_packet(request_topic(dev_id), payload));
+    return true;
+}
+
+void OrcaMqttConnection::connect_and_read() {
+    auto connection = std::make_shared<Connection>();
+    {
+        std::lock_guard<std::mutex> lock(connection_mutex);
+        active_connection = connection;
+        if (stopping.load()) {
+            active_connection.reset();
+            return;
+        }
+    }
+
+    auto clear_connection = [this, connection] {
+        close_connection(*connection);
+        std::lock_guard<std::mutex> lock(connection_mutex);
+        if (active_connection == connection)
+            active_connection.reset();
+    };
+
+    try {
+        Endpoint endpoint;
+        if (!parse_endpoint(current_config.url, endpoint)) {
+            throw std::runtime_error("invalid Orca Cloud WebSocket endpoint");
+        }
+
+
+        ws_handshake(*connection, current_config, endpoint);
+
+        // Auth precedence: a bearer_provider authenticates the WebSocket upgrade, so the
+        // CONNECT username/password fields are omitted entirely (the cloud form).
+        const bool use_bearer = static_cast<bool>(current_config.bearer_provider);
+        ws_write(*connection, make_connect_packet(current_config.client_id,
+                                                  use_bearer ? std::string() : current_config.username,
+                                                  use_bearer ? std::string() : current_config.password,
+                                                  current_config.keepalive_seconds));
+
+        boost::beast::flat_buffer buffer;
+        expires_after(*connection, std::chrono::seconds(10));
+        boost::system::error_code connack_error;
+        ws_read(*connection, buffer, connack_error);
+        if (connack_error)
+            throw boost::system::system_error(connack_error, "read Orca MQTT CONNACK");
+        // Beast leaves this expiry armed after the synchronous CONNACK read above;
+        // disable it before starting the long-lived async WebSocket session.
+        expires_never(*connection);
+        const std::string connack = boost::beast::buffers_to_string(buffer.data());
+        // rc: 0 accepted, 1..5 refusal, -1 malformed/not a CONNACK.
+        const int rc = (connack.size() == 4 && static_cast<uint8_t>(connack[0]) == 0x20)
+                           ? static_cast<int>(static_cast<uint8_t>(connack[3]))
+                           : -1;
+        m_last_connack_rc.store(rc);
+        if (rc != 0) {
+            if (rc == 4 || rc == 5) {
+                // Bad credentials / not authorized — retrying cannot help. Make run()'s
+                // loop exit and unblock any waiting start().
+                stopping.store(true);
+                {
+                    std::lock_guard<std::mutex> lock(mutex);
+                    initial_completed = true;
+                    initial_result    = false;
+                }
+                initial_cv.notify_all();
+            }
+            throw std::runtime_error("Orca MQTT CONNECT refused rc=" + std::to_string(rc));
+        }
+
+        // The subscription acknowledgement belongs to this MQTT session. Clear
+        // the previous session's state before notifying the owner, because the
+        // reconnect callback immediately queues the printer's initial requests.
+        {
+            std::lock_guard<std::mutex> lock(mutex);
+            acknowledged_subscriptions.clear();
+            pending_subscribe_packets.clear();
+        }
+        connection->async_session_started.store(true);
+        notify_state(true);
+        reconnect_delay_seconds.store(1); // a fresh CONNACK resets the backoff
+        send_current_subscriptions(connection);
+        start_async_read(connection);
+        schedule_keepalive(connection);
+    const std::size_t handlers_run = connection->io_context.run();
+    if (handlers_run == 0 && !stopping.load())
+        throw std::runtime_error("Orca MQTT event loop stopped unexpectedly");
+        if (connection->terminal_error && !stopping.load())
+            throw boost::system::system_error(connection->terminal_error, "read Orca MQTT message");
+        clear_connection();
+        if (!stopping.load())
+            notify_state(false);
+    } catch (...) {
+        clear_connection();
+        throw;
+    }
+}
+
+void OrcaMqttConnection::send_current_subscriptions(const std::shared_ptr<Connection>& conn) {
+    std::vector<std::string> topics;
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        topics.assign(subscriptions.begin(), subscriptions.end());
+        acknowledged_subscriptions.clear();
+        pending_subscribe_packets.clear();
+        for (const std::string& topic : topics)
+            pending_subscriptions.erase(topic);
+    }
+    for (const std::string& topic : topics) {
+        const uint16_t packet_id = next_packet_id++;
+        {
+            std::lock_guard<std::mutex> lock(mutex);
+            pending_subscribe_packets[packet_id] = topic;
+        }
+        enqueue_packet(conn, make_subscribe_packet(packet_id, topic, 1));
+    }
+}
+
+void OrcaMqttConnection::send_pending_subscriptions(const std::shared_ptr<Connection>& conn) {
+    std::vector<std::string> subscribe_topics;
+    std::vector<std::string> unsubscribe_topics;
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        subscribe_topics.assign(pending_subscriptions.begin(), pending_subscriptions.end());
+        unsubscribe_topics.assign(pending_unsubscriptions.begin(), pending_unsubscriptions.end());
+        pending_subscriptions.clear();
+        pending_unsubscriptions.clear();
+    }
+    for (const std::string& topic : subscribe_topics) {
+        const uint16_t packet_id = next_packet_id++;
+        {
+            std::lock_guard<std::mutex> lock(mutex);
+            pending_subscribe_packets[packet_id] = topic;
+        }
+        enqueue_packet(conn, make_subscribe_packet(packet_id, topic, 1));
+    }
+    for (const std::string& topic : unsubscribe_topics) {
+        const uint16_t packet_id = next_packet_id++;
+        enqueue_packet(conn, make_unsubscribe_packet(packet_id, topic));
+    }
+}
+
+void OrcaMqttConnection::handle_packet(const std::string& packet) {
+    if (packet.size() < 2) {
+        return;
+    }
+    const uint8_t header = static_cast<uint8_t>(packet[0]);
+    const uint8_t packet_type = header >> 4;
+    if (packet_type != 3) { // Only QoS 0 PUBLISH carries printer status.
+        if (packet_type == 9 && packet.size() >= 5) {
+            const uint16_t packet_id = (static_cast<unsigned int>(static_cast<uint8_t>(packet[2])) << 8) |
+                                       static_cast<unsigned int>(static_cast<uint8_t>(packet[3]));
+            std::ostringstream result_codes;
+            for (size_t index = 4; index < packet.size(); ++index) {
+                if (index != 4)
+                    result_codes << ',';
+                result_codes << "0x" << std::hex << static_cast<unsigned int>(static_cast<uint8_t>(packet[index]));
+            }
+
+            // Each production SUBSCRIBE packet currently contains one topic.
+            // MQTT grants QoS 0 or 1 for a requested QoS 1 subscription; 0x80
+            // means the subscription was rejected.
+            const uint8_t result = static_cast<uint8_t>(packet[4]);
+            std::string topic;
+            std::deque<std::pair<std::string, std::string>> requests;
+            {
+                std::lock_guard<std::mutex> lock(mutex);
+                auto pending = pending_subscribe_packets.find(packet_id);
+                if (pending != pending_subscribe_packets.end()) {
+                    topic = pending->second;
+                    pending_subscribe_packets.erase(pending);
+                    for (auto it = pending_requests.begin(); it != pending_requests.end();) {
+                        if (report_topic(it->first) == topic) {
+                            requests.push_back(std::move(*it));
+                            it = pending_requests.erase(it);
+                        } else {
+                            ++it;
+                        }
+                    }
+                    if (result == 0 || result == 1) {
+                        acknowledged_subscriptions.insert(topic);
+                    }
+                }
+            }
+            if (topic.empty()) {
+            } else if (result == 0 || result == 1) {
+                for (const auto& request : requests) {
+                    if (!send_request(request.first, request.second)) {
+                    }
+                }
+            } else {
+            }
+        }
+        return;
+    }
+    size_t index = 1;
+    size_t multiplier = 1;
+    size_t remaining = 0;
+    uint8_t encoded = 0;
+    do {
+        if (index >= packet.size() || multiplier > 128 * 128 * 128) {
+            return;
+        }
+        encoded = static_cast<uint8_t>(packet[index++]);
+        remaining += (encoded & 0x7f) * multiplier;
+        multiplier *= 128;
+    } while ((encoded & 0x80) != 0);
+    const size_t remaining_end = index + remaining;
+    if (remaining_end > packet.size() || remaining < 2 || index + 2 > remaining_end) {
+        return;
+    }
+    const uint16_t topic_length = (static_cast<uint8_t>(packet[index]) << 8) |
+                                  static_cast<uint8_t>(packet[index + 1]);
+    index += 2;
+    if (topic_length > packet.size() - index) {
+        return;
+    }
+    const std::string topic(packet.data() + index, topic_length);
+    index += topic_length;
+    if (((header >> 1) & 0x03) != 0) {
+        if (index + 2 > remaining_end) {
+            return;
+        }
+        index += 2; // QoS 1/2 packet identifier; the service currently sends QoS 0.
+    }
+    const size_t payload_size = remaining_end - index;
+    // topic is "device/<id>/report" (or "/request"); hand the id up, drop anything else.
+    std::string dev_id;
+    if (topic.rfind("device/", 0) == 0) {
+        const size_t id_start = 7;
+        const size_t id_end   = topic.rfind('/');
+        if (id_end != std::string::npos && id_end > id_start)
+            dev_id = topic.substr(id_start, id_end - id_start);
+    }
+    if (dev_id.empty()) {
+    } else if (on_message) {
+        on_message(dev_id, packet.substr(index, remaining_end - index));
+    } else {
+    }
+}
+
+void OrcaMqttConnection::notify_state(bool is_now_connected) {
+    StateHandler callback;
+    bool initial = false;
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        connected = is_now_connected;
+        initial   = !initial_completed;
+        if (initial) {
+            initial_result    = is_now_connected;
+            initial_completed = true;
+        }
+        callback = on_state;
+    }
+    if (initial)
+        initial_cv.notify_all();
+    else if (callback)
+        callback(is_now_connected, false);
+}
+
+void OrcaMqttConnection::run() {
+    while (!stopping.load()) {
+        const int retry_seconds = reconnect_delay_seconds.load();
+        const uint64_t attempt = ++m_attempt_number;
+        try {
+            connect_and_read();
+        } catch (const std::exception& error) {
+            if (!stopping.load())
+                notify_state(false);
+        }
+        if (stopping.load())
+            break;
+        // Grow the backoff only across attempts that never reached CONNACK; a
+        // successful connection resets reconnect_delay_seconds to 1 (connect_and_read).
+        reconnect_delay_seconds.store(std::min(retry_seconds * 2, 30));
+        std::unique_lock<std::mutex> lock(mutex);
+        state_cv.wait_for(lock, std::chrono::seconds(retry_seconds), [this] { return stopping.load(); });
+    }
+}
+
+} // namespace Slic3r

src/slic3r/Utils/OrcaMqttConnection.hpp

@@ -0,0 +1,155 @@
+#ifndef slic3r_OrcaMqttConnection_hpp_
+#define slic3r_OrcaMqttConnection_hpp_
+
+#include <boost/asio/ssl.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/beast/ssl.hpp>
+#include <boost/beast/websocket.hpp>
+#include <atomic>
+#include <condition_variable>
+#include <deque>
+#include <functional>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <set>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+#include <cstddef>
+#include <cstdint>
+
+namespace Slic3r {
+
+// Minimal MQTT 3.1.1 codec + WebSocket transport (ws:// and wss://), shared by the
+// LAN (OrcaSonar) and cloud (fleet) printer connections. Both PUBLISH
+// commands to device/<id>/request and SUBSCRIBE device/<id>/report; Config is the
+// only per-transport difference.
+class OrcaMqttConnection
+{
+public:
+    using TokenProvider  = std::function<std::string()>;
+    using MessageHandler = std::function<void(const std::string&, const std::string&)>;
+    using StateHandler   = std::function<void(bool connected, bool initial)>;
+
+    struct Endpoint { std::string host; std::string port; std::string target; };
+
+    struct Config {
+        std::string   url;
+        bool          use_tls = false;
+        std::string   ca_file;
+        TokenProvider bearer_provider;       // set => bearer on WS upgrade, CONNECT creds omitted
+        std::string   username;
+        std::string   password;
+        std::string   client_id  = "OrcaSlicer";
+        int           keepalive_seconds = 60;
+    };
+
+    static bool parse_endpoint(const std::string& url, Endpoint& endpoint);
+
+    // Build an MQTT 3.1.1 CONNECT packet. Clean-session is always set; the
+    // username/password connect flags and payload fields are added only when
+    // username is non-empty (the cloud form authenticates via a bearer on the
+    // WebSocket upgrade and omits CONNECT credentials). Public for unit tests.
+    static std::vector<uint8_t> make_connect_packet(const std::string& client_id,
+                                                    const std::string& username,
+                                                    const std::string& password,
+                                                    int keepalive_seconds);
+
+    // Topic-string helpers for the per-device request/report channels and the
+    // MQTT 3.1.1 PUBLISH / SUBSCRIBE / UNSUBSCRIBE packet builders. All public
+    // for unit tests. make_publish_packet emits QoS 0 (no packet identifier).
+    static std::string request_topic(const std::string& dev_id);            // "device/<id>/request"
+    static std::string report_topic(const std::string& dev_id);             // "device/<id>/report"
+    static std::vector<uint8_t> make_publish_packet(const std::string& topic, const std::string& payload);
+    static std::vector<uint8_t> make_subscribe_packet(uint16_t packet_id, const std::string& topic, uint8_t qos);
+    static std::vector<uint8_t> make_unsubscribe_packet(uint16_t packet_id, const std::string& topic);
+
+    ~OrcaMqttConnection();
+
+    bool start(const Config& config, MessageHandler on_message, StateHandler on_state);
+    void stop();
+    // True while the worker thread is alive (connected OR retrying). Lets callers
+    // avoid restarting a healthy connection.
+    bool is_running() const;
+    // True once CONNACK has been received and the socket has not since dropped.
+    bool is_connected() const { return connected.load(); }
+    bool subscribe(const std::string& dev_id);
+    bool unsubscribe(const std::string& dev_id);
+    // Last MQTT CONNACK return code: 0 ok, 1..5 refusal, -1 none seen this attempt.
+    int  last_connack_rc() const { return m_last_connack_rc.load(); }
+    void clear_subscriptions();
+    bool send_request(const std::string& dev_id, const std::string& payload);
+
+private:
+    // The endpoint may be either a TLS (wss://) or a plaintext (ws://) WebSocket;
+    // Connection holds whichever one is engaged and the ws_* helpers below
+    // dispatch on it.
+    using TlsWebSocket   = boost::beast::websocket::stream<
+        boost::asio::ssl::stream<boost::beast::tcp_stream>>;
+    using PlainWebSocket = boost::beast::websocket::stream<boost::beast::tcp_stream>;
+    struct Connection;
+
+    static void append_string(std::vector<uint8_t>& packet, const std::string& value);
+    static void prepend_remaining_length(std::vector<uint8_t>& packet, size_t length);
+    static std::vector<uint8_t> make_ping_packet();
+
+    // Transport dispatch: each forwards to conn.wss (TLS) or conn.ws (plaintext).
+    // These synchronous operations are called only by the MQTT worker during
+    // connection setup. Once the MQTT session is established, all socket I/O is
+    // asynchronous and owned by that worker's io_context.
+    void        ws_write(Connection& conn, const std::vector<uint8_t>& packet);
+    std::size_t ws_read(Connection& conn, boost::beast::flat_buffer& buffer, boost::system::error_code& ec);
+    void        ws_handshake(Connection& conn, const Config& config, const Endpoint& endpoint);
+    void        close_connection(Connection& conn);
+    void        enqueue_packet(const std::shared_ptr<Connection>& conn, std::vector<uint8_t> packet);
+    void        start_async_write(const std::shared_ptr<Connection>& conn);
+    void        start_async_read(const std::shared_ptr<Connection>& conn);
+    void        schedule_keepalive(const std::shared_ptr<Connection>& conn);
+    void        post_packet(const std::shared_ptr<Connection>& conn, std::vector<uint8_t> packet);
+    // Ask the MQTT worker to emit subscription changes on its own io_context.
+    void flush_subscription_change();
+    void connect_and_read();
+    void send_current_subscriptions(const std::shared_ptr<Connection>& conn);
+    void send_pending_subscriptions(const std::shared_ptr<Connection>& conn);
+    void handle_packet(const std::string& packet);
+    void notify_state(bool is_now_connected);
+    void run();
+
+    std::atomic_bool stopping{true};
+    std::atomic_int reconnect_delay_seconds{1};
+    // Serialises the whole of start() and stop() against each other, so the UI
+    // thread's stop() (disconnect / dtor) cannot race the connect thread's start()
+    // into a concurrent worker.join(). Recursive because start() calls stop().
+    std::recursive_mutex lifecycle_mutex;
+    std::thread worker;
+    std::mutex mutex;
+    std::mutex connection_mutex;
+    std::shared_ptr<Connection> active_connection;
+    std::condition_variable initial_cv;
+    std::condition_variable state_cv;
+    Config current_config;
+    MessageHandler on_message;
+    StateHandler on_state;
+    // Full report-topic strings ("device/<id>/report"), not bare device ids.
+    std::set<std::string> subscriptions;
+    std::set<std::string> pending_subscriptions;
+    std::set<std::string> pending_unsubscriptions;
+    // Requests for a subscribed device wait until the corresponding SUBACK is
+    // received. Otherwise an immediate pushall response can be published by
+    // the broker before this client is actually subscribed to the report topic.
+    std::set<std::string> acknowledged_subscriptions;
+    std::map<uint16_t, std::string> pending_subscribe_packets;
+    std::deque<std::pair<std::string, std::string>> pending_requests;
+    std::atomic<uint16_t> next_packet_id{1};
+    std::atomic<int> m_last_connack_rc{-1};
+    uint64_t m_attempt_number{0};       // worker-thread diagnostic sequence
+    bool initial_result{false};
+    bool initial_completed{false};
+    std::atomic_bool connected{false};
+};
+
+} // namespace Slic3r
+
+#endif // slic3r_OrcaMqttConnection_hpp_

src/slic3r/Utils/OrcaPrinterAgent.hpp

@@ -3,20 +3,29 @@
 
 #include "IPrinterAgent.hpp"
 #include "ICloudServiceAgent.hpp"
+#include "OrcaCloudServiceAgent.hpp"
+#include "OrcaMqttConnection.hpp"
+#include <atomic>
+#include <cstdint>
+#include <functional>
 #include "bambu_networking.hpp"
 #include <string>
 #include <mutex>
 #include <memory>
+#include <thread>
 
 namespace Slic3r {
 
+class OrcaCloudServiceAgent;
+
 /**
- * OrcaPrinterAgent - Stub implementation for printer operations.
+ * OrcaPrinterAgent - OrcaSonar MQTT printer agent.
  *
- * All printer-related operations are currently stubs that return success.
- * Actual printer connectivity requires the BBL SDK or future Orca implementation.
+ * LAN and cloud commands use the same OrcaSonar protocol payloads; only the
+ * MQTT connection selected by route_send() differs.
  */
-class OrcaPrinterAgent : public IPrinterAgent {
+class OrcaPrinterAgent : public IPrinterAgent
+{
 public:
     explicit OrcaPrinterAgent(std::string log_dir);
     ~OrcaPrinterAgent() override;
@@ -26,9 +35,18 @@ public:
     // ========================================================================
 
     void set_cloud_agent(std::shared_ptr<ICloudServiceAgent> cloud) override;
+    CameraStreamMode get_camera_stream_mode() const override;
+    std::string get_camera_url() const override;
+    int list_printer_files(const std::string& dev_id, PrinterFileListFn callback) override;
+    int get_printer_file_thumbnail(const std::string& dev_id, const std::string& path, PrinterFileThumbnailFn callback) override;
+    int delete_printer_file(const std::string& dev_id, const std::string& path, PrinterFileDeleteFn callback) override;
+    int get_printer_file_metadata(const std::string& dev_id, const std::string& path, PrinterFileMetadataFn callback) override;
 
     // Communication
     int send_message(std::string dev_id, std::string json_str, int qos, int flag) override;
+    bool supports_command(const std::string& dev_id, const std::string& command) const override;
+    bool supports_feature(const std::string& dev_id, const std::string& feature) const override;
+    bool uses_filament_mapping() const override { return true; }
     int connect_printer(const PrinterConnectionParams& params) override;
     int disconnect_printer() override;
     int send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag) override;
@@ -43,6 +61,7 @@ public:
     // Machine Selection
     std::string get_user_selected_machine() override;
     int set_user_selected_machine(std::string dev_id) override;
+    int unbind(std::string dev_id) override;
 
     /**
      * Get agent information.
@@ -54,6 +73,8 @@ public:
 
     // Print Job Operations
     int start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
+    // Unimplemented on OrcaSonar: reports a non-success result so callers fall back to
+    // start_print() instead of treating the missing send as success.
     int start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
     int start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
     int start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
@@ -69,10 +90,162 @@ public:
     int set_on_local_message_fn(OnMessageFn fn) override;
     int set_queue_on_main_fn(QueueOnMainFn fn) override;
 
+    int command_ams_refresh_rfid(std::string dev_id, int ams_id, int tray_id, int sequence_id, bool lan_mode) override;
+    int command_ams_calibrate(std::string dev_id, int ams_id, int sequence_id, bool lan_mode) override;
+    int command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode) override;
+    int command_start_camera(std::string dev_id) override;
+    int command_xyz_abs(std::string dev_id, int sequence_id, bool lan_mode) override;
+    int command_auto_leveling(std::string dev_id, int sequence_id, bool lan_mode) override;
+    int command_go_home(std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode) override;
+    int command_set_bed(std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode) override;
+    int command_set_nozzle(std::string dev_id, int temp, int sequence_id, bool lan_mode) override;
+    int command_axis_control(std::string dev_id,
+                             std::string axis,
+                             double unit,
+                             double input_val,
+                             int speed,
+                             bool is_core_xy,
+                             bool supports_mqtt_axis_control,
+                             int sequence_id,
+                             bool lan_mode) override;
+
+    // Test-only: drive emit_connect_sequence directly (no socket).
+    void run_connect_sequence_for_test(const std::string& dev_id)
+    {
+        emit_connect_sequence(dev_id, [](const std::string&) {}, [](const std::string&) {});
+    }
+
+    // Test-only: advance the LAN connection epoch without a connect/disconnect cycle.
+    void bump_lan_generation_for_test() { ++m_lan_generation; }
+    // Test-only: the same for the (independent) cloud selection epoch.
+    void bump_cloud_generation_for_test() { ++m_cloud_generation; }
+
+    FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::subscription; }
+
+protected:
+    // Forward one inbound printer message to on_message_fn or on_local_message_fn (marshalled onto the UI
+    // thread via queue_on_main_fn when set). Body of every connection's MessageHandler.
+    void deliver_to_sink(const std::string& dev_id, const std::string& payload, bool local);
+
+    // Extract OrcaSonar's print.ipcam.stream_mode from LAN reports before they
+    // are forwarded to the GUI. The getters below then read this agent-owned state.
+    void parse_ipcam_info(const std::string& dev_id, const std::string& payload);
+
+    // Orca-dialect -> Bambu-dialect compatibility shim for inbound reports: the single
+    // place Orca Protocol JSON is rewritten into the shapes MachineObject::parse_json
+    // already handles, so parse_json needs no Orca-specific changes. Self-contained
+    // (its cache is a function-local static) and deletable together with its call site
+    // once parse_json reads the Orca dialect natively. See the definition for the
+    // per-rule detail. Returns the payload unchanged when no rule applies.
+    std::string merge_capabilities(const std::string& dev_id, const std::string& payload);
+    void forget_device_capabilities(const std::string& dev_id);
+    int prepare_outgoing_request(const std::string& dev_id, const std::string& payload,
+                                 std::string& command, std::string& prepared) const;
+
+    // Report the asynchronous LAN connection state using the same callback contract as
+    // the other printer agents. The transport result cannot be returned by
+    // connect_printer(), which only starts the worker.
+    void dispatch_local_connect(int state, const std::string& dev_id, const std::string& message);
+
+    // The LAN inbound-message handler for one connection generation: forwards to
+    // deliver_to_sink only while `generation` is still the live epoch.
+    std::function<void(const std::string&, const std::string&)> make_lan_message_handler(uint64_t generation);
+
+    // Pure LAN-address parsing + client-id. protected static so the test Probe reaches them.
+    static bool parse_lan_endpoint(const std::string& dev_ip, std::string& host, std::string& port);
+    static std::string make_lan_client_id(const std::string& dev_id);
+
+    // Pure serializer for PrintParams::ams_mapping2 -> print.gcode_file.filament_mapping.
+    // Entries are re-keyed by their array position; {255,255} is dropped. Empty when the
+    // input is empty, malformed, or has no usable entries. protected static for the test Probe.
+    static nlohmann::json build_filament_mapping(const std::string& ams_mapping2);
+
+    // Pure builder for the print.gcode_file command payload. A non-empty mapping is
+    // included as filament_mapping; an empty one is omitted so the payload is
+    // byte-identical to an unmapped print. protected static for the test Probe.
+    static nlohmann::json build_gcode_file_payload(const std::string& sequence_id,
+                                                   const std::string& target,
+                                                   const nlohmann::json& filament_mapping);
+
+    // Pure JSON -> entries normalization for OrcaSonar's /server/files/list reply.
+    // protected static so the test Probe reaches it.
+    static std::vector<PrinterFileEntry> parse_file_list(const std::string& body);
+
+    // Pick the widest thumbnail path from OrcaSonar's /server/files/thumbnails
+    // reply (the array is smallest-first). Empty when none carry a path.
+    static std::string parse_thumbnail_path(const std::string& body);
+
+    // Pure JSON -> metadata normalization for OrcaSonar's /server/files/metadata
+    // reply. Missing or malformed fields default to 0. protected static for the Probe.
+    static PrinterFileMetadata parse_file_metadata(const std::string& body);
+
+    // Percent-encode each '/'-separated segment for a Moonraker URL while keeping
+    // the separators intact. protected static for the test Probe.
+    static std::string encode_file_path(const std::string& path);
+    // Test hook: the ws:// URL connect_printer built for the current LAN session ("" if none).
+    std::string lan_connection_target() const;
+    // Shared post-connect sequence: SUBSCRIBE, then pushing.start, pushall,
+    // info.get_version, info.get_capabilities. Runs identically on LAN and cloud.
+    void on_connected(const std::string& dev_id, OrcaMqttConnection* conn, uint64_t generation);
+
+    // The post-connect command sequence, factored behind a seam so a test can
+    // observe the SUBSCRIBE + 4 request payloads without a live OrcaMqttConnection.
+    virtual void emit_connect_sequence(const std::string& dev_id,
+                                       std::function<void(const std::string&)> subscribe,
+                                       std::function<void(const std::string&)> request);
+    static std::string seq(int n); // decimal string in the OrcaSlicer 20000..29999 band
+    static std::string build_pushing_start(const std::string& sequence_id);
+    static std::string build_pushing_stop(const std::string& sequence_id);
+    static std::string build_pushall(const std::string& sequence_id);
+    static std::string build_get_version(const std::string& sequence_id);
+    static std::string build_get_capabilities(const std::string& sequence_id);
+
 private:
+    class OrcaSonarDiscovery;
+
     std::string log_dir;
     std::string selected_machine;
+
+    enum CurrentConn { NONE, CLOUD, LAN };
+    static const char* connection_type_name(CurrentConn connection);
+
+    // The transport for the printer currently selected by the UI.  LAN and
+    // cloud sessions have separate connection objects, so this is selection
+    // state rather than an inference from whichever socket happens to exist.
+    CurrentConn m_current_connection = NONE;
+
     std::shared_ptr<ICloudServiceAgent> m_cloud_agent;
+    std::unique_ptr<OrcaMqttConnection> lan_mqtt_connection;
+
+    // Two independent epochs: a cloud (de)selection must not fence the live LAN
+    // feed, and vice versa. Each transport's connect thread and inbound handler
+    // compare against their own counter only.
+    std::atomic<uint64_t> m_lan_generation{0};
+    std::atomic<uint64_t> m_cloud_generation{0};
+
+    // The short-lived threads that run the blocking initial connect for the current
+    // LAN / cloud session. Joined members (never detached) so they cannot outlive
+    // *this or the connection they hold a raw pointer to.
+    std::thread m_lan_connect_thread;
+    std::thread m_cloud_connect_thread;
+
+    std::unique_ptr<OrcaSonarDiscovery> m_discovery;
+
+    std::string m_lan_dev_id; // guarded by state_mutex
+    std::string m_lan_url;    // guarded by state_mutex — the Config.url of the live LAN session
+    bool m_lan_use_ssl = false; // guarded by state_mutex
+    std::string m_lan_ca_file; // guarded by state_mutex
+    CameraStreamMode m_camera_stream_mode = CameraStreamMode::none; // guarded by state_mutex
+    std::string m_camera_url; // guarded by state_mutex
+
+    OrcaCloudServiceAgent* get_orca_cloud_agent();
+
+    OrcaMqttConnection* get_appropriate_mqtt_connection(bool is_lan = true);
+    static bool parse_nonnegative_command_id(const std::string& value, int& result);
+
+    // Route one command payload to device/<dev_id>/request on the LAN or the shared
+    // cloud connection. The uniform send path for both send_message* overrides.
+    int route_send(bool is_lan, const std::string& dev_id, const std::string& json_str);
 
     // Callbacks
     OnMsgArrivedFn on_ssdp_msg_fn;

src/slic3r/Utils/QidiPrinterAgent.cpp

@@ -14,7 +14,6 @@
 #include "libslic3r/Preset.hpp"
 #include <map>
 #include <sstream>
-#include <thread>
 #include <string>
 #include <utility>
 #include <vector>
@@ -37,15 +36,6 @@ bool has_visible_base_preset(const PresetCollection& filaments, const std::strin
     return false;
 }
 
-// RAII decrement for MoonrakerPrinterAgent::filament_fetch_in_flight — guarantees the
-// counter drops back down on every exit path (early return or fall-through) inside the
-// detached fetch thread below, so ~MoonrakerPrinterAgent()'s wait loop can't stall forever.
-struct InFlightGuard
-{
-    std::atomic<int>& counter;
-    ~InFlightGuard() { counter.fetch_sub(1, std::memory_order_relaxed); }
-};
-
 } // anonymous namespace
 
 const std::string QidiPrinterAgent_VERSION = "0.0.1";
@@ -59,148 +49,51 @@ AgentInfo QidiPrinterAgent::get_agent_info_static()
     return AgentInfo{"qidi", "Qidi", QidiPrinterAgent_VERSION, "Qidi printer agent"};
 }
 
-FilamentSyncMode QidiPrinterAgent::get_filament_sync_mode() const
+bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
-        return FilamentSyncMode::subscription;
-    return FilamentSyncMode::pull;
-}
+    std::string error;
 
-bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
-{
-    if (sync_mode != get_filament_sync_mode())
+    // 1. Fetch device info and infer series_id
+    std::string series_id;
+    {
+        MoonrakerDeviceInfo info;
+        if (fetch_device_info(device_info.base_url, device_info.api_key, info, error)) {
+            series_id = infer_series_id(info.model_id, info.dev_name);
+        }
+    }
+    if (series_id.empty()) {
+        // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
+        series_id = infer_series_id(device_info.model_id, device_info.model_name);
+    }
+
+    // 2. Fetch filament dictionary
+    QidiFilamentDict dict;
+    if (!fetch_filament_dict(device_info.base_url, device_info.api_key, dict, error)) {
+        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
+    }
+
+    // 3. Fetch slot info and build AmsTrayData directly
+    std::vector<AmsTrayData> trays;
+    int                      box_count = 0;
+    if (!fetch_slot_info(device_info.base_url, device_info.api_key, dict, series_id, trays, box_count, error)) {
+        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
         return false;
+    }
 
-    // Snapshot only what the fetch needs, rather than reading device_info live from the
-    // background thread below — device_info can be concurrently rewritten by a reconnect
-    // on another thread while this fetch is still in flight.
-    ConnectionSettings connection = get_connection_settings();
-    std::string model_id   = device_info.model_id;
-    std::string model_name = device_info.model_name;
-
-    filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
-
-    std::thread([this, connection = std::move(connection), model_id, model_name]() mutable {
-        InFlightGuard guard{filament_fetch_in_flight};
-
-        std::string error;
-
-        // 1. Fetch device info and infer series_id
-        std::string series_id;
-        {
-            MoonrakerDeviceInfo info;
-            if (fetch_device_info(connection, info, error)) {
-                series_id = infer_series_id(info.model_id, info.dev_name);
-            }
-        }
-        if (series_id.empty()) {
-            // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
-            series_id = infer_series_id(model_id, model_name);
-        }
-
-        // 2. Fetch filament dictionary
-        QidiFilamentDict dict;
-        if (!fetch_filament_dict(connection, dict, error)) {
-            BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
-        }
-
-        // 3. Fetch slot info and build AmsTrayData directly
-        std::vector<AmsTrayData> trays;
-        int box_count = 0;
-        if (!fetch_slot_info(connection, dict, series_id, trays, box_count, error)) {
-            BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
-            return;
-        }
-
-        // 4. Build the AMS payload
-        build_ams_payload(box_count, box_count * 4 - 1, trays);
-    }).detach();
+    // 4. Build the AMS payload
+    build_ams_payload(box_count, box_count * 4 - 1, trays);
     return true;
 }
 
-bool QidiPrinterAgent::apply_box_mapping(const PrintParams& params) const
-{
-    // enable_box mirrors task_use_ams: engage the multi-color box only when this
-    // job actually routes filament through it. (See qidi-ams-findings.md §2/§8.3 —
-    // if firmware treats enable_box as "a box exists" rather than "use it this job",
-    // switch this gate to HasAms()/box_count instead.)
-    const int enable = params.task_use_ams ? 1 : 0;
-    if (!send_gcode(device_info.dev_id, "SAVE_VARIABLE VARIABLE=enable_box VALUE=" + std::to_string(enable))) {
-        BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: failed to set enable_box";
-        return false;
-    }
-
-    // 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)
-        return true;
-
-    if (params.ams_mapping.empty()) {
-        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::apply_box_mapping: enable_box set but ams_mapping is empty";
-        return true;
-    }
-
-    // ams_mapping (v0) is a JSON array indexed by filament/tool; each value is the
-    // physical box slot (-1 = unmapped). Mirror it onto the printer's value_t<tool>
-    // variables: SAVE_VARIABLE VARIABLE=value_t<tool> VALUE='slot<n>'.
-    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
-        const std::string gcode = "SAVE_VARIABLE VARIABLE=value_t" + std::to_string(tool) +
-                                  " VALUE=\"'slot" + std::to_string(slot) + "'\"";
-        if (!send_gcode(device_info.dev_id, gcode)) {
-            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: failed to set value_t" << tool;
-            return false;
-        }
-    }
-    return true;
-}
-
-int QidiPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
-{
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_local_print(std::move(params), update_fn, cancel_fn);
-}
-
-int QidiPrinterAgent::start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
-{
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_print(std::move(params), update_fn, cancel_fn, wait_fn);
-}
-
-int QidiPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
-{
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_WR_UPLOAD_FTP_FAILED;
-    return MoonrakerPrinterAgent::start_local_print_with_record(std::move(params), update_fn, cancel_fn, wait_fn);
-}
-
-int QidiPrinterAgent::start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
-{
-    if (!apply_box_mapping(params))
-        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
-    return MoonrakerPrinterAgent::start_sdcard_print(std::move(params), update_fn, cancel_fn);
-}
-
-bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
+bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
+                                       const std::string&        api_key,
                                        const QidiFilamentDict&   dict,
                                        const std::string&        series_id,
                                        std::vector<AmsTrayData>& trays,
                                        int&                      box_count,
                                        std::string&              error)
 {
-    std::string url = join_url(connection.base_url, "/printer/objects/query?save_variables=variables");
+    std::string url = join_url(base_url, "/printer/objects/query?save_variables=variables");
     for (int i = 0; i < 16; ++i) {
         url += "&box_stepper%20slot" + std::to_string(i) + "=runout_button";
     }
@@ -210,9 +103,8 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
     std::string http_error;
 
     auto http = Http::get(url);
-    configure_http(http, connection);
-    if (!connection.api_key.empty()) {
-        http.header("X-Api-Key", connection.api_key);
+    if (!api_key.empty()) {
+        http.header("X-Api-Key", api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)
@@ -237,10 +129,20 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
         return false;
     }
 
-    nlohmann::json status;
-    nlohmann::json variables;
-    if (!parse_slot_response(response_body, status, variables, error))
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    if (json.is_discarded()) {
+        error = "Invalid JSON response";
         return false;
+    }
+
+    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) {
@@ -315,45 +217,20 @@ bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
     return true;
 }
 
-bool QidiPrinterAgent::parse_slot_response(const std::string& response_body,
-                                           nlohmann::json&    status,
-                                           nlohmann::json&    variables,
-                                           std::string&       error)
-{
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-    if (json.is_discarded()) {
-        error = "Invalid JSON response";
-        return false;
-    }
-
-    if (!json.is_object() || !json.contains("result") || !json["result"].is_object() || !json["result"].contains("status") ||
-        !json["result"]["status"].is_object() || !json["result"]["status"].contains("save_variables") ||
-        !json["result"]["status"]["save_variables"].is_object() || !json["result"]["status"]["save_variables"].contains("variables") ||
-        !json["result"]["status"]["save_variables"]["variables"].is_object()) {
-        // why: Qidi firmware may send null here, but json::value() throws for it.
-        error = "Unexpected JSON structure: save_variables.variables must be an object";
-        return false;
-    }
-
-    status    = json["result"]["status"];
-    variables = status["save_variables"]["variables"];
-    return true;
-}
-
-bool QidiPrinterAgent::fetch_filament_dict(const ConnectionSettings& connection,
+bool QidiPrinterAgent::fetch_filament_dict(const std::string& base_url,
+                                           const std::string& api_key,
                                            QidiFilamentDict& dict,
                                            std::string& error) const
 {
-    std::string url = join_url(connection.base_url, "/server/files/config/officiall_filas_list.cfg");
+    std::string url = join_url(base_url, "/server/files/config/officiall_filas_list.cfg");
 
     std::string response_body;
     bool        success = false;
     std::string http_error;
 
     auto http = Http::get(url);
-    configure_http(http, connection);
-    if (!connection.api_key.empty()) {
-        http.header("X-Api-Key", connection.api_key);
+    if (!api_key.empty()) {
+        http.header("X-Api-Key", api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)

src/slic3r/Utils/QidiPrinterAgent.hpp

@@ -3,7 +3,6 @@
 
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
-#include "nlohmann/json_fwd.hpp"
 
 #include <map>
 #include <string>
@@ -23,23 +22,7 @@ public:
     // Override filament sync (Qidi-specific implementation)
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
-    static bool parse_slot_response(const std::string& response_body,
-                                    nlohmann::json&    status,
-                                    nlohmann::json&    variables,
-                                    std::string&       error);
-
-    // Print operations — emit QiDi multi-color box config, then delegate to base.
-    int start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
-    int start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
-    int start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn) override;
-    int start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
-
-    FilamentSyncMode get_filament_sync_mode() const override;
-
 private:
-    // Push enable_box + value_t<tool> SAVE_VARIABLEs before a print starts.
-    // Returns false if any command fails (caller should abort the print).
-    bool apply_box_mapping(const PrintParams& params) const;
     struct QidiFilamentDict
     {
         std::map<int, std::string> colors;
@@ -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

@@ -7,9 +7,6 @@
 
 #include "nlohmann/json.hpp"
 #include <boost/log/trivial.hpp>
-#include <chrono>
-#include <sstream>
-#include <thread>
 #include <vector>
 #include <string>
 #include "libslic3r/Preset.hpp"
@@ -23,13 +20,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();
-}
 
 // Safely access a parallel array by index, returning a fallback if out of bounds.
 template<typename T>
@@ -86,31 +76,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"};
@@ -146,149 +111,127 @@ std::string SnapmakerPrinterAgent::combine_filament_type(const std::string& type
     return base;
 }
 
-bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
 {
-    (void) dev_id;
-    if (sync_mode != get_filament_sync_mode())
+    std::string url = join_url(device_info.base_url, "/printer/objects/query?print_task_config&filament_detect");
+
+    std::string response_body;
+    bool        success = false;
+    std::string http_error;
+
+    auto http = Http::get(url);
+    if (!device_info.api_key.empty()) {
+        http.header("X-Api-Key", device_info.api_key);
+    }
+    http.timeout_connect(5)
+        .timeout_max(10)
+        .on_complete([&](std::string body, unsigned status) {
+            if (status == 200) {
+                response_body = body;
+                success       = true;
+            } else {
+                http_error = "HTTP error: " + std::to_string(status);
+            }
+        })
+        .on_error([&](std::string body, std::string err, unsigned status) {
+            http_error = err;
+            if (status > 0) {
+                http_error += " (HTTP " + std::to_string(status) + ")";
+            }
+        })
+        .perform_sync();
+
+    if (!success) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
         return false;
+    }
 
-    const std::string base_url = device_info.base_url;
-    const std::string api_key  = device_info.api_key;
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    if (json.is_discarded()) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
+        return false;
+    }
 
-    filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
+    // Navigate to result.status.print_task_config
+    if (!json.contains("result") || !json["result"].contains("status") ||
+        !json["result"]["status"].contains("print_task_config")) {
+        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
+        return false;
+    }
 
-    std::thread([this, base_url, api_key]() {
-        struct InFlightGuard
-        {
-            std::atomic<int>& counter;
-            ~InFlightGuard() { counter.fetch_sub(1, std::memory_order_relaxed); }
-        } guard{filament_fetch_in_flight};
+    auto& ptc = json["result"]["status"]["print_task_config"];
 
-        const std::string url = join_url(base_url, "/printer/objects/query?print_task_config&filament_detect");
+    // Read parallel arrays from print_task_config
+    auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
+    auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
+    auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
+    auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
+    auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
 
-        std::string response_body;
-        bool success = false;
-        std::string http_error;
+    const int slot_count = static_cast<int>(filament_exist.size());
+    if (slot_count == 0) {
+        BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
+        return false;
+    }
 
-        auto http = Http::get(url);
-        if (!api_key.empty()) {
-            http.header("X-Api-Key", api_key);
-        }
-        http.timeout_connect(5)
-            .timeout_max(10)
-            .on_complete([&](std::string body, unsigned status) {
-                if (status == 200) {
-                    response_body = body;
-                    success       = true;
+    // Read NFC filament_detect data for temperature info (optional)
+    nlohmann::json nfc_info;
+    if (json["result"]["status"].contains("filament_detect") &&
+        json["result"]["status"]["filament_detect"].contains("info")) {
+        nfc_info = json["result"]["status"]["filament_detect"]["info"];
+    }
+
+    static const std::string empty_str;
+    static const std::string default_color = "FFFFFFFF";
+
+    std::vector<AmsTrayData> trays;
+    trays.reserve(slot_count);
+
+    for (int i = 0; i < slot_count; ++i) {
+        AmsTrayData tray;
+        tray.slot_index   = i;
+        tray.has_filament = filament_exist[i];
+
+        if (tray.has_filament) {
+            tray.tray_type     = combine_filament_type(safe_at(filament_type, i, empty_str),
+                                                       safe_at(filament_sub_type, i, empty_str));
+            tray.tray_color    = safe_at(filament_color, i, default_color);
+
+            auto* bundle = GUI::wxGetApp().preset_bundle;
+            // Try to find a matching preset for this filament based on vendor, type and color.
+            // If not found, default to traditional search by type only or generic type mapping.
+            if (bundle) {
+                std::string vendor      = safe_at(filament_vendor, i, empty_str);
+                std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
+                                                                                       tray.tray_color);
+
+                if (!filament_id.empty()) {
+                    tray.tray_info_idx = filament_id;
+                    BOOST_LOG_TRIVIAL(warning) << "Filament sync: Found manufacturer-specific profile for slot " << i << ": "
+                                               << filament_id;
                 } else {
-                    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;
-        }
-
-        auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-        if (json.is_discarded()) {
-            BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
-            return;
-        }
-
-        // Navigate to result.status.print_task_config
-        if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("print_task_config")) {
-            BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
-            return;
-        }
-
-        auto& ptc = json["result"]["status"]["print_task_config"];
-
-        // Read parallel arrays from print_task_config
-        auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
-        auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
-        auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
-        auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
-        auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
-
-        const int slot_count = static_cast<int>(filament_exist.size());
-        if (slot_count == 0) {
-            BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
-            return;
-        }
-
-        // Read NFC filament_detect data for temperature info (optional)
-        nlohmann::json nfc_info;
-        if (json["result"]["status"].contains("filament_detect") && json["result"]["status"]["filament_detect"].contains("info")) {
-            nfc_info = json["result"]["status"]["filament_detect"]["info"];
-        }
-
-        static const std::string empty_str;
-        static const std::string default_color = "FFFFFFFF";
-
-        std::vector<AmsTrayData> trays;
-        trays.reserve(slot_count);
-
-        for (int i = 0; i < slot_count; ++i) {
-            AmsTrayData tray;
-            tray.slot_index   = i;
-            tray.has_filament = filament_exist[i];
-
-            if (tray.has_filament) {
-                tray.tray_type  = combine_filament_type(safe_at(filament_type, i, empty_str), safe_at(filament_sub_type, i, empty_str));
-                tray.tray_color = safe_at(filament_color, i, default_color);
-
-                auto* bundle = GUI::wxGetApp().preset_bundle;
-                // Try to find a matching preset for this filament based on vendor, type and color.
-                // If not found, default to traditional search by type only or generic type mapping.
-                if (bundle) {
-                    std::string vendor      = safe_at(filament_vendor, i, empty_str);
-                    std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
-                                                                                           tray.tray_color);
-
-                    if (!filament_id.empty()) {
-                        tray.tray_info_idx = filament_id;
-                        BOOST_LOG_TRIVIAL(warning)
-                            << "Filament sync: Found manufacturer-specific profile for slot " << i << ": " << filament_id;
-                    } else {
-                        tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
-                    }
-                } else {
-                    tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
-                }
-
-                // Extract NFC temperature data if available
-                if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
-                    auto& nfc_slot     = nfc_info[i];
-                    std::string vendor = nfc_slot.value("VENDOR", "NONE");
-                    if (vendor != "NONE" && !vendor.empty()) {
-                        tray.bed_temp    = nfc_slot.value("BED_TEMP", 0);
-                        tray.nozzle_temp = nfc_slot.value("FIRST_LAYER_TEMP", 0);
-                    }
+                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
                 }
+            } else {
+                tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
             }
 
-            trays.emplace_back(std::move(tray));
+            // Extract NFC temperature data if available
+            if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
+                auto& nfc_slot = nfc_info[i];
+                std::string vendor = nfc_slot.value("VENDOR", "NONE");
+                if (vendor != "NONE" && !vendor.empty()) {
+                    tray.bed_temp    = nfc_slot.value("BED_TEMP", 0);
+                    tray.nozzle_temp = nfc_slot.value("FIRST_LAYER_TEMP", 0);
+                }
+            }
         }
 
-        build_ams_payload(1, slot_count - 1, trays);
-    }).detach();
+        trays.emplace_back(std::move(tray));
+    }
 
+    build_ams_payload(1, slot_count - 1, trays);
     return true;
 }
 
-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 {
@@ -19,19 +17,10 @@ public:
     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 { return device_info.base_url + "/server/files/camera/monitor.jpg"; }
 
 private:
     // Combine filament_type + filament_sub_type into a unified type string
     static std::string combine_filament_type(const std::string& type, const std::string& sub_type);
-
-    void start_camera_monitor();
-    void on_status_loop_tick(const std::string& dev_id) override;
-
-    std::atomic<int64_t> m_camera_last_fire_ms{0};
 };
 
 } // namespace Slic3r

tests/fff_print/test_multifilament.cpp

@@ -49,6 +49,20 @@ static std::set<int> tools_for_role(const std::string& gcode, const std::string&
     return tools;
 }
 
+// Every id named by a Tn command anywhere in `gcode`. A non-BBL single-extruder multi-filament
+// setup emits T<filament_id>, and that id is what the Klipper toolchange macro consumes.
+static std::set<int> tool_ids(const std::string& gcode)
+{
+    std::set<int> tools;
+    GCodeReader reader;
+    reader.parse_buffer(gcode, [&tools](GCodeReader&, const GCodeReader::GCodeLine& line) {
+        const std::string cmd(line.cmd());
+        if (cmd.size() >= 2 && cmd[0] == 'T' && std::isdigit((unsigned char)cmd[1]))
+            tools.insert(std::stoi(cmd.substr(1)));
+    });
+    return tools;
+}
+
 // X where the nozzle sits while each tagged _WAIT_FOR_TEMP_ON_WIPE_TOWER M109 blocks:
 // the nearest preceding G1 carrying an X (the park travel emitted just before the wait).
 static std::vector<double> wait_park_xs(const std::string& gcode)
@@ -296,6 +310,29 @@ TEST_CASE("Each feature prints with its assigned filament (three filaments)", "[
     CHECK(tools_for_role(gcode, "infill")    == std::set<int>{ 1 }); // filament 2
 }
 
+// The per-print wire mapping keys each entry by the filament's index in the config filament
+// arrays (the ams_mapping2 position). Pin that the id the toolchange emits is that index even
+// when the used filaments skip a middle one: filament 2 (index 1) is configured but unused, so
+// a renumbering to the used set would emit {0, 1} instead of {0, 2} and aim the map at the
+// wrong lane.
+TEST_CASE("Toolchange ids keep the config index of the used filament when a middle filament is unused", "[MultiFilament]")
+{
+    const std::string gcode = slice({ cube(20) },
+        multifilament_config(3, {
+            { "sparse_infill_filament_id",  1 },
+            { "internal_solid_filament_id", 1 },
+            { "top_surface_filament_id",    1 },
+            { "bottom_surface_filament_id", 1 },
+            { "outer_wall_filament_id",     3 },
+            { "inner_wall_filament_id",     3 },
+            { "skirt_loops",                0 },
+            { "brim_type",                  "no_brim" },
+        }));
+    CHECK(tools_for_role(gcode, "perimeter") == std::set<int>{ 2 }); // filament 3
+    CHECK(tools_for_role(gcode, "infill")    == std::set<int>{ 0 }); // filament 1
+    CHECK(tool_ids(gcode)                    == std::set<int>{ 0, 2 });
+}
+
 // The override must survive tool ordering: object 1's walls print on their filament's
 // tool, object 0 stays on the first. If dropped, every wall prints on tool 0.
 TEST_CASE("Per-object wall filament override is honored", "[MultiFilament]")

tests/libslic3r/CMakeLists.txt

@@ -25,6 +25,7 @@ add_executable(${_TEST_NAME}_tests
     test_toolordering_nozzle_group.cpp
     test_parallel_resolve.cpp
     test_preset_bundle_loading.cpp
+    test_preset_bundle_ams_sync.cpp
     test_preset_setting_id.cpp
     test_preset_diff.cpp
     test_vendor_cache.cpp

tests/libslic3r/test_preset_bundle_ams_sync.cpp

@@ -0,0 +1,155 @@
+#include <catch2/catch_all.hpp>
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "libslic3r/Preset.hpp"
+#include "libslic3r/PresetBundle.hpp"
+
+using namespace Slic3r;
+
+namespace {
+
+// In-memory system filament preset. Mirrors the helper in test_preset_bundle_loading.cpp.
+Preset &add_system_filament(PresetBundle &bundle, const std::string &name, const std::string &filament_id, const std::string &filament_type)
+{
+    DynamicPrintConfig config(bundle.filaments.default_preset().config);
+    config.option<ConfigOptionString>(BBL_JSON_KEY_INHERITS, true)->value = "";
+    config.option<ConfigOptionStrings>("filament_type", true)->values    = {filament_type};
+    Preset &preset = bundle.filaments.load_preset(std::string(), name, config, /*select=*/false);
+    preset.is_system   = true;
+    preset.filament_id = filament_id;
+    return preset;
+}
+
+// One AMS tray entry as build_filament_ams_list produces it.
+DynamicPrintConfig make_tray(const std::string &filament_id, const std::string &filament_type, const std::string &color, const std::string &ams_id,
+                             const std::string &slot_id)
+{
+    DynamicPrintConfig tray;
+    tray.set_key_value("filament_id", new ConfigOptionStrings{filament_id});
+    tray.set_key_value("filament_type", new ConfigOptionStrings{filament_type});
+    tray.set_key_value("filament_colour", new ConfigOptionStrings{color});
+    tray.set_key_value("filament_colour_type", new ConfigOptionStrings{"1"});
+    tray.set_key_value("filament_multi_colour", new ConfigOptionStrings{});
+    tray.set_key_value("ams_id", new ConfigOptionStrings{ams_id});
+    tray.set_key_value("slot_id", new ConfigOptionStrings{slot_id});
+    return tray;
+}
+
+} // namespace
+
+// A tray the printer UI wrote carries a material type but no OrcaSlicer preset id. It must still
+// sync, resolved to Generic <type> with the tray's own color.
+TEST_CASE("AMS sync resolves a printer-set tray to Generic by material type", "[Preset][AMS]")
+{
+    PresetBundle bundle;
+    add_system_filament(bundle, "Generic PETG @Q2", "OFYPdQJh", "PETG");
+    add_system_filament(bundle, "Generic PLA @Q2", "GFL99", "PLA");
+
+    bundle.filament_ams_list[0] = make_tray("OFYPdQJh", "PETG", "#FE717A", "0", "0"); // preset-backed
+    bundle.filament_ams_list[1] = make_tray("", "PETG", "#898F9B", "0", "1");         // printer-set, no id
+    bundle.filament_ams_list[2] = make_tray("", "PLA", "#FAFAFA", "0", "2");          // printer-set, no id
+    bundle.filament_ams_list[3] = make_tray("", "", "#000000", "0", "3");             // empty slot
+
+    std::vector<std::pair<DynamicPrintConfig *, std::string>> unknowns;
+    std::map<int, AMSMapInfo>                                 maps;
+    MergeFilamentInfo                                         merge;
+
+    const unsigned int count = bundle.sync_ams_list(unknowns, /*use_map=*/false, maps, /*enable_append=*/false, merge);
+
+    CHECK(count == 3);
+    REQUIRE(bundle.filament_presets.size() == 3);
+    CHECK(bundle.filament_presets[0] == "Generic PETG @Q2");
+    CHECK(bundle.filament_presets[1] == "Generic PETG @Q2");
+    CHECK(bundle.filament_presets[2] == "Generic PLA @Q2");
+
+    const ConfigOptionStrings *colors = bundle.project_config.option<ConfigOptionStrings>("filament_colour");
+    REQUIRE(colors != nullptr);
+    REQUIRE(colors->values.size() == 3);
+    CHECK(colors->values[0] == "#FE717A");
+    CHECK(colors->values[1] == "#898F9B");
+    CHECK(colors->values[2] == "#FAFAFA");
+}
+
+// Without a preset id and without a material type there is nothing to resolve; the tray stays
+// skipped in a direct sync.
+TEST_CASE("AMS sync skips a tray without a preset id or a material type", "[Preset][AMS]")
+{
+    PresetBundle bundle;
+    add_system_filament(bundle, "Generic PETG @Q2", "OFYPdQJh", "PETG");
+    bundle.filament_ams_list[0] = make_tray("", "", "#000000", "0", "0");
+
+    std::vector<std::pair<DynamicPrintConfig *, std::string>> unknowns;
+    std::map<int, AMSMapInfo>                                 maps;
+    MergeFilamentInfo                                         merge;
+
+    CHECK(bundle.sync_ams_list(unknowns, /*use_map=*/false, maps, /*enable_append=*/false, merge) == 0);
+    CHECK(bundle.filament_presets.empty());
+}
+
+// Guard the pre-existing behavior: a non-empty id that matches no preset still resolves by type.
+TEST_CASE("AMS sync still resolves an unmatched preset id by material type", "[Preset][AMS]")
+{
+    PresetBundle bundle;
+    add_system_filament(bundle, "Generic PETG @Q2", "OFYPdQJh", "PETG");
+    bundle.filament_ams_list[0] = make_tray("REMOVED_ID", "PETG", "#123456", "0", "0");
+
+    std::vector<std::pair<DynamicPrintConfig *, std::string>> unknowns;
+    std::map<int, AMSMapInfo>                                 maps;
+    MergeFilamentInfo                                         merge;
+
+    CHECK(bundle.sync_ams_list(unknowns, /*use_map=*/false, maps, /*enable_append=*/false, merge) == 1);
+    REQUIRE(bundle.filament_presets.size() == 1);
+    CHECK(bundle.filament_presets[0] == "Generic PETG @Q2");
+}
+
+// Mapping-mode sync used to force "Generic PLA" for an id-less tray; it must use the type instead.
+TEST_CASE("AMS sync in mapping mode resolves a printer-set tray to Generic, not Generic PLA", "[Preset][AMS]")
+{
+    PresetBundle bundle;
+    add_system_filament(bundle, "Generic PETG @Q2", "OFYPdQJh", "PETG");
+    add_system_filament(bundle, "Generic PLA @Q2", "GFL99", "PLA");
+
+    bundle.filament_presets                                                     = {"Generic PLA @Q2"};
+    bundle.project_config.option<ConfigOptionStrings>("filament_colour")->values      = {"#000000"};
+    bundle.project_config.option<ConfigOptionStrings>("filament_colour_type")->values = {"1"};
+
+    bundle.filament_ams_list[0] = make_tray("", "PETG", "#898F9B", "0", "1");
+
+    std::map<int, AMSMapInfo> maps;
+    maps[0] = AMSMapInfo{"0", "1"};
+
+    std::vector<std::pair<DynamicPrintConfig *, std::string>> unknowns;
+    MergeFilamentInfo                                         merge;
+
+    const unsigned int count = bundle.sync_ams_list(unknowns, /*use_map=*/true, maps, /*enable_append=*/false, merge);
+
+    CHECK(count == 1);
+    REQUIRE(bundle.filament_presets.size() == 1);
+    CHECK(bundle.filament_presets[0] == "Generic PETG @Q2");
+    CHECK(bundle.project_config.option<ConfigOptionStrings>("filament_colour")->values[0] == "#898F9B");
+}
+
+// The dialog builds ams_mapping2 one entry per filament_presets index, while the generated
+// G-code's toolchange names the filament's index in the slice's filament config arrays. Those
+// are the same index only if full_config() collects the filament arrays in filament_presets
+// order; if a refactor reorders one side, every mapped print aims at the wrong lane.
+TEST_CASE("Full config filament arrays follow the selected filament preset order", "[Preset][AMS]")
+{
+    PresetBundle bundle;
+    add_system_filament(bundle, "Generic PETG @Q2", "OFYPdQJh", "PETG");
+    add_system_filament(bundle, "Generic PLA @Q2", "GFL99", "PLA");
+
+    // Deliberately not the load order: the arrays must follow this selection.
+    bundle.filament_presets = {"Generic PLA @Q2", "Generic PETG @Q2"};
+
+    const DynamicPrintConfig full = bundle.full_config(/*apply_extruder=*/false);
+    REQUIRE(full.option<ConfigOptionStrings>("filament_type") != nullptr);
+    CHECK(full.option<ConfigOptionStrings>("filament_settings_id")->values == std::vector<std::string>{"Generic PLA @Q2", "Generic PETG @Q2"});
+    CHECK(full.option<ConfigOptionStrings>("filament_type")->values == std::vector<std::string>{"PLA", "PETG"});
+    // The AMS sync matches trays by filament_id, so this array must follow the same order.
+    CHECK(full.option<ConfigOptionStrings>("filament_ids")->values == std::vector<std::string>{"GFL99", "OFYPdQJh"});
+}

tests/libslic3r/test_preset_bundle_loading.cpp

@@ -1601,6 +1601,23 @@ TEST_CASE("Filaments offered for a machine follow the app's compatibility rule",
     }
 }
 
+// An agent-reported model id (SSDP modelNumber, manual binding) must resolve to the display
+// name printer profiles use as printer_model; the AMS dialogs look filaments up by it.
+TEST_CASE("Printer model ids resolve to vendor display names", "[Preset][Bundle]")
+{
+    PresetBundle bundle;
+    VendorProfile qidi("Qidi");
+    qidi.name = "Qidi";
+    VendorProfile::PrinterModel model;
+    model.model_id = "Qidi-Q1Pro";
+    model.name     = "Qidi Q1 Pro";
+    qidi.models.push_back(model);
+    bundle.vendors.emplace(qidi.id, qidi);
+
+    CHECK(bundle.get_printer_model_display_name("Qidi-Q1Pro") == "Qidi Q1 Pro");
+    CHECK(bundle.get_printer_model_display_name("unknown-model").empty());
+}
+
 
 namespace {
 

tests/slic3rutils/CMakeLists.txt

@@ -6,6 +6,7 @@ add_executable(${_TEST_NAME}_tests
     test_dev_mapping.cpp
     test_filament_bitmap_utils.cpp
     test_device_progress.cpp
+    test_ams_item.cpp
     test_device_manager_integration.cpp
     test_web_media_controller.cpp
     test_scene_raycaster.cpp
@@ -24,7 +25,8 @@ 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_orca_mqtt_connection.cpp
+    test_orca_printer_agent.cpp
     test_plugin_install.cpp
     test_plugin_lifecycle.cpp
     test_plugin_printer_agent.cpp

tests/slic3rutils/orca_mqtt_mock_broker.hpp

@@ -0,0 +1,325 @@
+#pragma once
+
+// In-process plaintext MQTT-over-WebSocket broker for the OrcaMqtt tests.
+//
+// It speaks just enough of MQTT 3.1.1 to drive OrcaMqttConnection /
+// OrcaPrinterAgent end to end without a real network: CONNECT/CONNACK,
+// SUBSCRIBE/SUBACK, UNSUBSCRIBE/UNSUBACK, client PUBLISH (QoS 0), PINGREQ and
+// DISCONNECT. The outbound PUBLISH frame is built with the production
+// OrcaMqttConnection::make_publish_packet() so the tests never depend on a
+// second, hand-rolled MQTT encoder.
+
+#include <slic3r/Utils/OrcaMqttConnection.hpp>
+
+#include <boost/asio.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/beast/websocket.hpp>
+
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+namespace orca_mqtt_test {
+
+namespace net   = boost::asio;
+namespace beast = boost::beast;
+namespace ws    = boost::beast::websocket;
+using tcp       = boost::asio::ip::tcp;
+
+// Decode an MQTT remaining-length varint starting at packet[offset].
+// Returns {value, bytes_consumed}; bytes_consumed == 0 means malformed.
+inline std::pair<std::size_t, std::size_t> mqtt_decode_remaining_length(const std::string& packet, std::size_t offset)
+{
+    std::size_t value      = 0;
+    std::size_t multiplier = 1;
+    std::size_t used       = 0;
+    while (offset + used < packet.size() && used < 4) {
+        const std::uint8_t byte = static_cast<std::uint8_t>(packet[offset + used]);
+        value += static_cast<std::size_t>(byte & 0x7f) * multiplier;
+        multiplier *= 128;
+        ++used;
+        if ((byte & 0x80) == 0)
+            return {value, used};
+    }
+    return {0, 0};
+}
+
+inline bool mqtt_topic_is_request(const std::string& topic)
+{
+    static const std::string suffix = "/request";
+    return topic.size() >= suffix.size() &&
+           topic.compare(topic.size() - suffix.size(), suffix.size(), suffix) == 0;
+}
+
+class MockBroker
+{
+public:
+    // refuse_auth: answer every CONNECT with CONNACK rc 5 (not authorized) and
+    // close, so the reconnect/refusal paths can be exercised.
+    explicit MockBroker(bool refuse_auth = false) : m_refuse_auth(refuse_auth), m_acceptor(m_io)
+    {
+        const tcp::endpoint endpoint(net::ip::make_address("127.0.0.1"), 0);
+        m_acceptor.open(endpoint.protocol());
+        m_acceptor.set_option(net::socket_base::reuse_address(true));
+        m_acceptor.bind(endpoint);
+        m_acceptor.listen(net::socket_base::max_listen_connections);
+        m_port = std::to_string(m_acceptor.local_endpoint().port());
+        // why: a non-blocking acceptor lets the accept loop poll a stop flag, so
+        // the destructor never has to interrupt a blocking accept().
+        m_acceptor.non_blocking(true);
+        m_thread = std::thread([this] { run(); });
+    }
+
+    ~MockBroker()
+    {
+        m_stopping.store(true);
+        drop_client();                     // unblocks the worker's blocking read
+        if (m_thread.joinable())
+            m_thread.join();
+        boost::system::error_code ec;
+        m_acceptor.close(ec);              // after join: the acceptor is worker-owned
+        m_io.stop();
+    }
+
+    MockBroker(const MockBroker&)            = delete;
+    MockBroker& operator=(const MockBroker&) = delete;
+
+    std::string ws_url() const { return "ws://127.0.0.1:" + m_port + "/mqtt"; }
+
+    std::pair<std::string, std::string> host_port() const { return {std::string("127.0.0.1"), m_port}; }
+
+    // Server -> client PUBLISH on device/<dev_id>/report.
+    void push_report(const std::string& dev_id, const std::string& payload)
+    {
+        const std::vector<std::uint8_t> packet =
+            Slic3r::OrcaMqttConnection::make_publish_packet("device/" + dev_id + "/report", payload);
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (!m_stream || !m_stream_ready)
+            return;
+        boost::system::error_code ec;
+        m_stream->binary(true);
+        m_stream->write(net::buffer(packet), ec); // a vanished client is not a test failure
+    }
+
+    // Force-close the live client socket; the worker's read returns an error and
+    // the accept loop picks up the client's reconnect.
+    void drop_client()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        close_client_locked();
+    }
+
+    // Payloads the client PUBLISHed to any device/<id>/request topic.
+    std::vector<std::string> received_requests() const
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_received_requests;
+    }
+
+    // MQTT CONNECTs seen; increments again after a reconnect.
+    int connect_count() const { return m_connect_count.load(); }
+
+    // MQTT PINGREQs seen while the client has no other traffic.
+    int ping_count() const { return m_ping_count.load(); }
+
+private:
+    void run()
+    {
+        try {
+            while (!m_stopping.load()) {
+                tcp::socket               socket(m_io);
+                boost::system::error_code ec;
+                m_acceptor.accept(socket, ec);
+                if (ec == net::error::would_block || ec == net::error::try_again) {
+                    std::this_thread::sleep_for(std::chrono::milliseconds(5));
+                    continue;
+                }
+                if (ec)
+                    return;
+                try {
+                    serve(std::move(socket));
+                } catch (...) {
+                    // a client dying mid-session must not take the broker down
+                }
+                std::lock_guard<std::mutex> lock(m_mutex);
+                close_client_locked();
+                m_stream.reset();
+            }
+        } catch (...) {
+            // never let an exception escape the broker thread
+        }
+    }
+
+    void serve(tcp::socket socket)
+    {
+        ws::stream<beast::tcp_stream>* stream = nullptr;
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            m_stream.emplace(std::move(socket));
+            m_stream_ready = false;
+            stream         = &*m_stream;
+        }
+        // why: no io_context is ever run here, so a tcp_stream timer would never
+        // fire; the sync operations below carry no timeout of their own.
+        beast::get_lowest_layer(*stream).expires_never();
+        stream->set_option(ws::stream_base::decorator(
+            [](ws::response_type& res) { res.set("Sec-WebSocket-Protocol", "mqtt"); }));
+
+        boost::system::error_code ec;
+        stream->accept(ec);
+        if (ec)
+            return;
+        stream->binary(true);
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            m_stream_ready = true;
+        }
+        read_loop(*stream);
+    }
+
+    // The client sends every MQTT packet as one binary WebSocket message, so one
+    // read yields exactly one packet.
+    void read_loop(ws::stream<beast::tcp_stream>& stream)
+    {
+        beast::flat_buffer buffer;
+        while (!m_stopping.load()) {
+            boost::system::error_code ec;
+            buffer.clear();
+            stream.read(buffer, ec);
+            if (ec)
+                return;
+            const std::string packet = beast::buffers_to_string(buffer.data());
+            if (packet.empty())
+                continue;
+            if (!handle_packet(stream, packet))
+                return;
+        }
+    }
+
+    // Returns false when the session must be closed.
+    bool handle_packet(ws::stream<beast::tcp_stream>& stream, const std::string& packet)
+    {
+        switch (static_cast<std::uint8_t>(packet[0]) & 0xf0) {
+        case 0x10: { // CONNECT
+            ++m_connect_count;
+            if (m_refuse_auth) {
+                write_packet(stream, {0x20, 0x02, 0x00, 0x05}); // CONNACK not authorized
+                return false;
+            }
+            write_packet(stream, {0x20, 0x02, 0x00, 0x00}); // CONNACK accepted
+            return true;
+        }
+        case 0x80: { // SUBSCRIBE (0x82) - packet id follows the remaining-length varint
+            const auto id = packet_id(packet);
+            if (id)
+                write_packet(stream, {0x90, 0x03, id->first, id->second, 0x00}); // SUBACK, QoS 0
+            return true;
+        }
+        case 0xa0: { // UNSUBSCRIBE (0xa2)
+            const auto id = packet_id(packet);
+            if (id)
+                write_packet(stream, {0xb0, 0x02, id->first, id->second}); // UNSUBACK
+            return true;
+        }
+        case 0x30: { // PUBLISH, QoS 0 (no packet identifier)
+            record_publish(packet);
+            return true;
+        }
+        case 0xc0: // PINGREQ
+            ++m_ping_count;
+            write_packet(stream, {0xd0, 0x00});
+            return true;
+        case 0xe0: // DISCONNECT
+            return false;
+        default:
+            return true;
+        }
+    }
+
+    // The two packet-identifier bytes sitting right after the remaining-length varint.
+    static std::optional<std::pair<std::uint8_t, std::uint8_t>> packet_id(const std::string& packet)
+    {
+        const auto varint = mqtt_decode_remaining_length(packet, 1);
+        if (varint.second == 0)
+            return std::nullopt;
+        const std::size_t pos = 1 + varint.second;
+        if (pos + 2 > packet.size())
+            return std::nullopt;
+        return std::make_pair(static_cast<std::uint8_t>(packet[pos]), static_cast<std::uint8_t>(packet[pos + 1]));
+    }
+
+    void record_publish(const std::string& packet)
+    {
+        const auto varint = mqtt_decode_remaining_length(packet, 1);
+        if (varint.second == 0)
+            return;
+        std::size_t pos = 1 + varint.second;
+        if (pos + 2 > packet.size())
+            return;
+        const std::size_t topic_len = (static_cast<std::size_t>(static_cast<std::uint8_t>(packet[pos])) << 8) |
+                                      static_cast<std::uint8_t>(packet[pos + 1]);
+        pos += 2;
+        if (pos + topic_len > packet.size())
+            return;
+        const std::string topic = packet.substr(pos, topic_len);
+        pos += topic_len;
+        const std::size_t end = std::min(packet.size(), 1 + varint.second + varint.first);
+        if (end < pos)
+            return;
+        if (!mqtt_topic_is_request(topic))
+            return;
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_received_requests.push_back(packet.substr(pos, end - pos));
+    }
+
+    // Every write - the worker's own replies and push_report() from the test
+    // thread - is serialised by m_mutex. The production client keeps all of its
+    // WebSocket operations on its MQTT worker instead.
+    void write_packet(ws::stream<beast::tcp_stream>& stream, const std::vector<std::uint8_t>& packet)
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        boost::system::error_code   ec;
+        stream.binary(true);
+        stream.write(net::buffer(packet), ec);
+    }
+
+    void close_client_locked()
+    {
+        if (!m_stream)
+            return;
+        m_stream_ready = false;
+        boost::system::error_code ec;
+        auto&                     socket = beast::get_lowest_layer(*m_stream).socket();
+        if (socket.cancel(ec))
+            return;
+        // shutdown() before close() is what actually wakes a blocking read on the
+        // worker thread; close() alone does not on POSIX.
+        if (socket.shutdown(tcp::socket::shutdown_both, ec))
+            return;
+        if (socket.close(ec))
+            return;
+    }
+
+    const bool                                   m_refuse_auth;
+    net::io_context                              m_io;
+    tcp::acceptor                                m_acceptor;
+    std::string                                  m_port;
+    std::thread                                  m_thread;
+    std::atomic_bool                             m_stopping{false};
+    std::atomic<int>                             m_connect_count{0};
+    std::atomic<int>                             m_ping_count{0};
+    mutable std::mutex                           m_mutex;
+    std::optional<ws::stream<beast::tcp_stream>> m_stream;      // guarded by m_mutex
+    bool                                         m_stream_ready = false; // guarded by m_mutex
+    std::vector<std::string>                     m_received_requests;    // guarded by m_mutex
+};
+
+} // namespace orca_mqtt_test

tests/slic3rutils/test_ams_item.cpp

@@ -0,0 +1,86 @@
+// why: match the GUI include order to avoid rpcndr.h byte/std::byte
+// ambiguity in the Windows COM headers.
+#ifdef WIN32
+    #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+    #endif
+    #ifndef NOMINMAX
+        #define NOMINMAX
+    #endif
+    #include <Windows.h>
+#endif
+
+#include <catch2/catch_all.hpp>
+
+#include <wx/timer.h>
+
+#include <nlohmann/json.hpp>
+
+#include "slic3r/GUI/Widgets/AMSItem.hpp"
+#include "slic3r/GUI/DeviceCore/DevFilaSystem.h"
+
+using json = nlohmann::json;
+using namespace Slic3r;
+using namespace Slic3r::GUI;
+
+// A configured slot the wire reports as having no filament (all material fields
+// present and empty) is "Empty", not the unknown "?" the UI draws for a tray
+// whose info is missing. The distinction must survive into the AMS panel model.
+TEST_CASE("Configured empty AMS trays remain distinct from unknown trays", "[AMSItem]")
+{
+    MachineObject machine(nullptr, nullptr, "test", "test-device", "127.0.0.1");
+    machine.printer_agent_id = "orca";
+
+    const json print_json = json::parse(R"({
+        "ams": {
+            "ams_exist_bits": "1",
+            "tray_exist_bits": "3",
+            "ams": [ { "id": "0", "info": "0001", "tray": [
+                { "id": "0", "tag_uid": "0000000000000000", "tray_info_idx": "", "tray_type": "", "tray_color": "00000000" },
+                { "id": "1" }
+            ] } ]
+        }
+    })");
+    DevFilaSystemParser::ParseV1_0(print_json, &machine, machine.GetFilaSystem().get(), false);
+
+    const auto& ams_list = machine.GetFilaSystem()->GetAmsList();
+    const auto  ams_it   = ams_list.find("0");
+    REQUIRE(ams_it != ams_list.end());
+    auto* ams = ams_it->second;
+    REQUIRE(ams != nullptr);
+    REQUIRE(ams->GetTray("0") != nullptr);
+    CHECK(ams->GetTray("0")->is_empty);
+
+    AMSinfo info;
+    REQUIRE(info.parse_ams_info(&machine, ams));
+    REQUIRE(info.cans.size() == 2);
+
+    CHECK(info.cans[0].is_empty);
+    CHECK(info.cans[0].material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND);
+    CHECK_FALSE(info.cans[1].is_empty);
+    CHECK(info.cans[1].material_state == AMSCanType::AMS_CAN_TYPE_THIRDBRAND);
+}
+
+TEST_CASE("Empty external slots remain distinct from unknown slots", "[AMSItem]")
+{
+    MachineObject machine(nullptr, nullptr, "test", "test-device", "127.0.0.1");
+    machine.printer_agent_id = "orca";
+
+    DevAmsTray empty_slot = machine.parse_vt_tray(json::parse(R"({
+        "id": "255", "tag_uid": "0000000000000000", "tray_info_idx": "", "tray_type": "", "tray_color": "00000000"
+    })"));
+    CHECK(empty_slot.is_empty);
+
+    AMSinfo empty_info;
+    empty_info.parse_ext_info(&machine, empty_slot);
+    CHECK(empty_info.cans[0].is_empty);
+    CHECK(empty_info.cans[0].material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL);
+
+    DevAmsTray unknown_slot = machine.parse_vt_tray(json::parse(R"({"id": "254"})"));
+    CHECK_FALSE(unknown_slot.is_empty);
+
+    AMSinfo unknown_info;
+    unknown_info.parse_ext_info(&machine, unknown_slot);
+    CHECK_FALSE(unknown_info.cans[0].is_empty);
+    CHECK(unknown_info.cans[0].material_state == AMSCanType::AMS_CAN_TYPE_VIRTUAL);
+}

tests/slic3rutils/test_device_manager_integration.cpp

@@ -3,7 +3,11 @@
 
 #include <slic3r/GUI/DeviceCore/DevManager.h>
 #include <slic3r/GUI/DeviceManager.hpp>
+#include <slic3r/GUI/DeviceCore/DevFilaSystem.h>
+#include <slic3r/GUI/FilamentMappingUtils.hpp>
 #include <libslic3r/AppConfig.hpp>
+#include <libslic3r/PresetBundle.hpp>
+#include <libslic3r/PrintConfig.hpp>
 #include "slic3r/Utils/IPrinterAgent.hpp"
 #include "slic3r/Utils/CloudProvider.hpp"
 #include <slic3r/Utils/NetworkAgent.hpp>
@@ -18,6 +22,8 @@
 #include <utility>
 
 using namespace Slic3r;
+using Slic3r::GUI::MappingSendError;
+using Slic3r::GUI::prepare_filament_mapping_for_send;
 using json = nlohmann::json;
 
 namespace {
@@ -49,6 +55,30 @@ public:
 
     AgentInfo get_agent_info() override { return m_info; }
 
+    // This test double represents a legacy agent, not OrcaPrinterAgent behavior.
+    bool supports_command(const std::string&, const std::string&) const override { return true; }
+
+    // It models whichever agent is registered under its id: only the Orca agent
+    // serializes per-print filament_mapping.
+    bool uses_filament_mapping() const override { return m_info.id == "orca"; }
+
+    using OrcaPrinterAgent::deliver_to_sink;
+
+    int send_message(std::string, std::string json_str, int, int) override
+    {
+        last_message = std::move(json_str);
+        return send_result;
+    }
+
+    int send_message_to_printer(std::string, std::string json_str, int, int) override
+    {
+        last_message = std::move(json_str);
+        return send_result;
+    }
+
+    std::string last_message;
+    int send_result = 0;
+
 private:
     AgentInfo m_info;
 };
@@ -160,3 +190,183 @@ TEST_CASE("Device manager filters and rehomes devices by printer-agent ownership
     CHECK(manager.get_my_machine_list("integration-agent-a").empty());
     CHECK(manager.get_my_machine_list("integration-agent-b").count(machine.dev_id) == 1);
 }
+
+TEST_CASE("Network agent rejects capability queries for a different device owner", "[DeviceManager][integration]")
+{
+    NetworkAgent network(nullptr, std::make_shared<TestPrinterAgent>("bbl"));
+
+    CHECK(network.owns_agent("bbl"));
+    CHECK_FALSE(network.owns_agent("orca"));
+    CHECK(network.supports_command("bbl", "device", "print.ams_control"));
+    CHECK_FALSE(network.supports_command("orca", "device", "print.ams_control"));
+    CHECK_FALSE(network.supports_feature("orca", "device", "filament_mapping"));
+
+    // The mapping dialect is queried the same way: a legacy owner never inherits
+    // Orca's, and a non-owner is never queried at all.
+    CHECK_FALSE(network.uses_filament_mapping("bbl"));
+    CHECK_FALSE(network.uses_filament_mapping("orca"));
+
+    NetworkAgent orca_network(nullptr, std::make_shared<TestPrinterAgent>("orca"));
+    CHECK(orca_network.uses_filament_mapping("orca"));
+    CHECK_FALSE(orca_network.uses_filament_mapping("bbl"));
+}
+
+// Send-time mapping policy belongs to the printer agent's dialect, not to an
+// agent id: the Orca dialect gets the no-AMS normalization plus both refusals.
+TEST_CASE("Per-print mapping send policy follows the owning agent's dialect", "[DeviceManager][integration]")
+{
+    auto orca_agent = std::make_shared<TestPrinterAgent>("orca");
+    NetworkAgent network(nullptr, orca_agent);
+    MachineObject obj(nullptr, &network, "test", "orca-mapping-policy", "127.0.0.1");
+    obj.printer_agent_id = "orca";
+
+    // No AMS: the auto-selected external spool is dropped before the capability
+    // gate, so it cannot refuse a print nobody mapped.
+    std::string external_only = R"([{"ams_id":255,"slot_id":0}])";
+    CHECK(prepare_filament_mapping_for_send(&obj, external_only, {}) == MappingSendError::none);
+    CHECK(external_only.empty());
+
+    // An AMS makes that a real target, but nothing advertised the capability yet.
+    obj.GetFilaSystem()->GetAmsList()["0"] = new DevAms("0", 0, DevAms::AMS);
+    std::string mapped = R"([{"ams_id":0,"slot_id":0}])";
+    CHECK(prepare_filament_mapping_for_send(&obj, mapped, {}) == MappingSendError::unsupported);
+    CHECK(mapped == R"([{"ams_id":0,"slot_id":0}])"); // the refusal leaves it intact
+
+    // Once the connector advertises the capability the mapping passes the gate.
+    orca_agent->deliver_to_sink(obj.get_dev_id(),
+                        R"({"info":{"command":"get_capabilities","supported_features":{"filament_mapping":true}}})",
+                        false);
+    CHECK(obj.printer_supports_feature("filament_mapping"));
+    CHECK(prepare_filament_mapping_for_send(&obj, mapped, {}) == MappingSendError::none);
+
+    // An unrecorded owner still sends through the active agent, so it takes
+    // that agent's dialect too rather than falling back to the legacy payload.
+    MachineObject unowned(nullptr, &network, "test", "orca-unowned", "127.0.0.1");
+    CHECK(unowned.printer_agent_id.empty());
+    CHECK(unowned.printer_uses_filament_mapping());
+    std::string unowned_external = R"([{"ams_id":255,"slot_id":0}])";
+    CHECK(prepare_filament_mapping_for_send(&unowned, unowned_external, {}) == MappingSendError::none);
+    CHECK(unowned_external.empty()); // the Orca normalization ran
+
+    // A partially mapped print is refused even while the capability holds.
+    FilamentInfo mapped_entry;
+    mapped_entry.ams_id = "0";
+    mapped_entry.slot_id = "0";
+    FilamentInfo unmapped_entry;
+    CHECK(prepare_filament_mapping_for_send(&obj, mapped, {mapped_entry, unmapped_entry}) ==
+          MappingSendError::incomplete);
+}
+
+// The legacy payload is the thing being protected: no normalization, no refusal.
+TEST_CASE("A legacy printer agent keeps its mapping payload untouched", "[DeviceManager][integration]")
+{
+    NetworkAgent network(nullptr, std::make_shared<TestPrinterAgent>("bbl"));
+    MachineObject obj(nullptr, &network, "test", "bbl-mapping-policy", "127.0.0.1");
+    obj.printer_agent_id = "bbl";
+
+    FilamentInfo mapped_entry;
+    mapped_entry.ams_id = "0";
+    mapped_entry.slot_id = "0";
+    FilamentInfo unmapped_entry;
+
+    std::string external_only = R"([{"ams_id":255,"slot_id":0}])";
+    CHECK(prepare_filament_mapping_for_send(&obj, external_only, {mapped_entry, unmapped_entry}) ==
+          MappingSendError::none);
+    CHECK(external_only == R"([{"ams_id":255,"slot_id":0}])");
+}
+
+TEST_CASE("AMS metadata retains setting_id for legacy printer agents", "[DeviceManager][integration]")
+{
+    ScopedAppConfig app_config;
+    auto printer_agent = std::make_shared<TestPrinterAgent>("bbl");
+    NetworkAgent network(nullptr, printer_agent);
+    DeviceManager manager(&network, false, &app_config.config);
+
+    BBLocalMachine machine;
+    machine.dev_id       = "bbl-setting-id";
+    machine.dev_name     = "Bambu setting id";
+    machine.dev_ip       = "192.0.2.32";
+    machine.printer_type = "C11";
+    MachineObject* obj = manager.insert_local_device(machine, "lan", "free", "", "access-code");
+    REQUIRE(obj != nullptr);
+
+    REQUIRE(obj->command_ams_filament_settings(0, 1, "GFL99", "preset-setting", "00FF00FF", "PLA", 190, 220) == 0);
+    const json payload = json::parse(printer_agent->last_message);
+    CHECK(payload["print"]["setting_id"] == "preset-setting");
+}
+
+TEST_CASE("AMS user settings do not update local state when publishing fails", "[DeviceManager][integration]")
+{
+    ScopedAppConfig app_config;
+    auto printer_agent = std::make_shared<TestPrinterAgent>("bbl");
+    NetworkAgent network(nullptr, printer_agent);
+    DeviceManager manager(&network, false, &app_config.config);
+
+    BBLocalMachine machine;
+    machine.dev_id       = "bbl-ams-setting-failure";
+    machine.dev_name     = "Bambu AMS settings";
+    machine.dev_ip       = "192.0.2.33";
+    machine.printer_type = "C11";
+    MachineObject* obj = manager.insert_local_device(machine, "lan", "free", "", "access-code");
+    REQUIRE(obj != nullptr);
+
+    auto& settings = obj->GetFilaSystem()->GetAmsSystemSetting();
+    settings.SetDetectOnInsertEnabled(false);
+    settings.SetDetectOnPowerupEnabled(false);
+    settings.SetDetectRemainEnabled(false);
+    printer_agent->send_result = -1;
+
+    CHECK(obj->command_ams_user_settings(true, true, true) != 0);
+    CHECK(settings.IsDetectOnInsertEnabled() == false);
+    CHECK(settings.IsDetectOnPowerupEnabled() == false);
+    CHECK(settings.IsDetectRemainEnabled() == false);
+}
+
+// The AMS dialogs resolve their filament list from the connected device's model. OrcaSonar's
+// model id is optional (the agent falls back to "orcasonar"), so the resolver must stand in
+// with the selected printer profile instead of yielding no model at all.
+TEST_CASE("Filament printer model resolution falls back to the selected profile", "[DeviceManager][integration]")
+{
+    PresetBundle bundle;
+
+    VendorProfile qidi("Qidi");
+    qidi.name = "Qidi";
+    VendorProfile::PrinterModel model;
+    model.model_id = "Qidi-Q1Pro";
+    model.name     = "Qidi Q1 Pro";
+    qidi.models.push_back(model);
+    bundle.vendors.emplace(qidi.id, qidi);
+
+    // A vendor model id the device reported resolves through the vendor catalog.
+    CHECK(resolve_filament_printer_model("Qidi-Q1Pro", &bundle) == "Qidi Q1 Pro");
+
+    // The OrcaSonar fallback id has no vendor model; the selected profile stands in.
+    CHECK(resolve_filament_printer_model("orcasonar", &bundle).empty());
+    bundle.printers.get_selected_preset().config.set_key_value("printer_model", new ConfigOptionString("Generic Klipper Printer"));
+    CHECK(resolve_filament_printer_model("orcasonar", &bundle) == "Generic Klipper Printer");
+    CHECK(resolve_filament_printer_model("", &bundle) == "Generic Klipper Printer");
+
+    CHECK(resolve_filament_printer_model("orcasonar", nullptr).empty());
+}
+
+// The per-tray K/N records are Bambu firmware's flow-dynamics calibration. Agents with no
+// printer-side records must not offer the AMS K/N controls (they would show a synthesized
+// default and then refuse to confirm it).
+TEST_CASE("Flow-dynamics K/N is offered for Bambu agents only", "[DeviceManager][integration]")
+{
+    MachineObject bbl(nullptr, nullptr, "test", "bbl-device", "127.0.0.1");
+    bbl.printer_agent_id = "bbl";
+    CHECK(bbl.supports_extrusion_cali());
+
+    MachineObject orca(nullptr, nullptr, "test", "orca-device", "127.0.0.1");
+    orca.printer_agent_id = "orca";
+    CHECK_FALSE(orca.supports_extrusion_cali());
+
+    MachineObject moonraker(nullptr, nullptr, "test", "moonraker-device", "127.0.0.1");
+    moonraker.printer_agent_id = "moonraker";
+    CHECK_FALSE(moonraker.supports_extrusion_cali());
+
+    // No agent id predates the agent split and keeps the Bambu path.
+    MachineObject legacy(nullptr, nullptr, "test", "legacy-device", "127.0.0.1");
+    CHECK(legacy.supports_extrusion_cali());
+}

tests/slic3rutils/test_orca_mqtt_connection.cpp

@@ -0,0 +1,243 @@
+#include <catch2/catch_test_macros.hpp>
+#include <slic3r/Utils/OrcaMqttConnection.hpp>
+
+#include "orca_mqtt_mock_broker.hpp"
+
+#include <chrono>
+#include <condition_variable>
+#include <cstddef>
+#include <cstdint>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <vector>
+
+using Slic3r::OrcaMqttConnection;
+
+// Offset of the CONNECT variable header: 1 (fixed header) + N remaining-length varint bytes.
+static size_t mqtt_varheader_offset(const std::vector<uint8_t>& p) {
+    size_t i = 1;
+    while (i < p.size() && (p[i] & 0x80)) ++i;   // skip varint continuation bytes
+    return i + 1;                                // + the final varint byte
+}
+
+TEST_CASE("OrcaMqtt parse_endpoint handles ws and wss", "[OrcaMqtt]") {
+    OrcaMqttConnection::Endpoint ep;
+
+    REQUIRE(OrcaMqttConnection::parse_endpoint("ws://printer.local:8280/mqtt", ep));
+    CHECK(ep.host   == "printer.local");
+    CHECK(ep.port   == "8280");
+    CHECK(ep.target == "/mqtt");
+
+    REQUIRE(OrcaMqttConnection::parse_endpoint("ws://10.0.0.5/mqtt", ep));
+    CHECK(ep.port == "80");
+
+    REQUIRE(OrcaMqttConnection::parse_endpoint("wss://api.example.com/api/v1/printers/abc/mqtt", ep));
+    CHECK(ep.host   == "api.example.com");
+    CHECK(ep.port   == "443");
+    CHECK(ep.target == "/api/v1/printers/abc/mqtt");
+
+    CHECK_FALSE(OrcaMqttConnection::parse_endpoint("http://x/y", ep));
+}
+
+TEST_CASE("OrcaMqtt CONNECT packet - no auth (cloud form)", "[OrcaMqtt]") {
+    auto p = OrcaMqttConnection::make_connect_packet("OrcaSlicer", "", "", 300);
+    REQUIRE(p.size() >= 12);
+    CHECK(p[0] == 0x10);                              // CONNECT fixed header
+    const size_t v = mqtt_varheader_offset(p);
+    CHECK(p[v + 0] == 0x00); CHECK(p[v + 1] == 0x04); // protocol name length
+    CHECK(p[v + 2] == 'M'); CHECK(p[v + 3] == 'Q');
+    CHECK(p[v + 4] == 'T'); CHECK(p[v + 5] == 'T');
+    CHECK(p[v + 6] == 0x04);                          // protocol level 3.1.1
+    CHECK(p[v + 7] == 0x02);                          // connect flags: clean session only
+    CHECK(((p[v + 8] << 8) | p[v + 9]) == 300);       // keepalive
+}
+
+TEST_CASE("OrcaMqtt CONNECT packet - username/password (LAN form)", "[OrcaMqtt]") {
+    auto p = OrcaMqttConnection::make_connect_packet("orcaslicer-lan-x", "orcasonar", "code123", 60);
+    CHECK(p[0] == 0x10);
+    const size_t v = mqtt_varheader_offset(p);
+    CHECK(p[v + 7] == (0x02 | 0x80 | 0x40));          // clean session + username + password flags
+    const std::string blob(p.begin(), p.end());
+    CHECK(blob.find("orcaslicer-lan-x") != std::string::npos);
+    CHECK(blob.find("orcasonar")        != std::string::npos);
+    CHECK(blob.find("code123")          != std::string::npos);
+}
+
+// Auth precedence (spec O3): when a bearer_provider is configured, connect_and_read
+// passes empty CONNECT credentials, so the packet must carry clean-session only and
+// no username/password flags or payload fields. (The precedence branch itself lives
+// in connect_and_read; the [.integration] cloud-style round trip exercises it live.)
+TEST_CASE("OrcaMqtt CONNECT omits creds when a bearer is configured", "[OrcaMqtt]") {
+    auto p = OrcaMqttConnection::make_connect_packet("cid", "", "", 60);
+    const size_t v = mqtt_varheader_offset(p);
+    CHECK(p[v + 7] == 0x02);                       // clean session only: no 0x80 / 0x40
+    const std::string blob(p.begin(), p.end());
+    CHECK(blob.find("orcasonar") == std::string::npos);
+}
+
+TEST_CASE("OrcaMqtt topic helpers", "[OrcaMqtt]") {
+    CHECK(OrcaMqttConnection::request_topic("abc") == "device/abc/request");
+    CHECK(OrcaMqttConnection::report_topic("abc")  == "device/abc/report");
+}
+
+TEST_CASE("OrcaMqtt PUBLISH packet QoS0", "[OrcaMqtt]") {
+    auto p = OrcaMqttConnection::make_publish_packet("device/abc/request", "{\"ok\":1}");
+    CHECK((p[0] & 0xf0) == 0x30);   // PUBLISH
+    CHECK((p[0] & 0x06) == 0x00);   // QoS 0
+    const std::string blob(p.begin(), p.end());
+    CHECK(blob.find("device/abc/request") != std::string::npos);
+    CHECK(blob.find("{\"ok\":1}")          != std::string::npos);
+}
+
+TEST_CASE("OrcaMqtt SUBSCRIBE packet", "[OrcaMqtt]") {
+    auto p = OrcaMqttConnection::make_subscribe_packet(7, "device/abc/report", 1);
+    CHECK(p[0] == 0x82);                          // SUBSCRIBE + reserved bit
+    const size_t v = mqtt_varheader_offset(p);
+    CHECK(((p[v] << 8) | p[v + 1]) == 7);         // packet id
+    CHECK(p.back() == 1);                         // requested QoS
+}
+
+TEST_CASE("OrcaMqtt send_request refuses when not connected", "[OrcaMqtt]") {
+    OrcaMqttConnection conn;
+    CHECK_FALSE(conn.send_request("abc", "{\"pushing\":{\"command\":\"pushall\",\"sequence_id\":\"20001\"}}"));
+}
+
+TEST_CASE("OrcaMqtt start takes a Config", "[OrcaMqtt]") {
+    OrcaMqttConnection conn;
+    OrcaMqttConnection::Config cfg;
+    cfg.url = "ws://127.0.0.1:1/mqtt";           // nothing listening
+    cfg.keepalive_seconds = 42;
+    // start() returns false (no server) but must compile with the Config overload
+    const bool ok = conn.start(cfg, [](auto, auto){}, [](bool, bool){});
+    CHECK_FALSE(ok);
+    CHECK(conn.last_connack_rc() == -1);
+    conn.stop();
+}
+
+TEST_CASE("MockBroker starts and reports a url", "[OrcaMqtt][.integration]") {
+    orca_mqtt_test::MockBroker b;
+    CHECK(b.ws_url().rfind("ws://127.0.0.1:", 0) == 0);
+    CHECK(b.connect_count() == 0);
+}
+
+// --- End-to-end integration: OrcaMqttConnection against the in-process MockBroker.
+// All hidden behind [.integration] (run explicitly). These prove a LAN-style config
+// (CONNECT username/password) and a cloud-style config (bearer on the WS upgrade,
+// no CONNECT creds) drive the *same* OrcaMqttConnection code path with identical
+// assertions.
+
+static void run_round_trip(bool use_tls_flag_only) {
+    orca_mqtt_test::MockBroker broker;
+    OrcaMqttConnection conn;
+    OrcaMqttConnection::Config cfg;
+    cfg.url = broker.ws_url();                     // plaintext regardless
+    cfg.use_tls = false;                           // the mock is plaintext; the flag path is unit-tested elsewhere
+    if (use_tls_flag_only) cfg.bearer_provider = []{ return std::string("tok"); };
+    else { cfg.username = "orcasonar"; cfg.password = "code"; }
+
+    // A mutex + condition_variable rather than a promise: the handler runs on the MQTT
+    // worker thread and a second inbound message would throw std::future_error there.
+    std::mutex              got_mutex;
+    std::condition_variable got_cv;
+    bool                    got_any = false;
+    std::string             got_id, got_payload;
+
+    REQUIRE(conn.start(cfg,
+        [&](const std::string& id, const std::string& payload){
+            {
+                std::lock_guard<std::mutex> l(got_mutex);
+                if (got_any) return;              // keep the first message only
+                got_any = true; got_id = id; got_payload = payload;
+            }
+            got_cv.notify_all();
+        },
+        [](bool,bool){}));
+    REQUIRE(conn.subscribe("dev-1"));
+    REQUIRE(conn.send_request("dev-1", R"({"pushing":{"command":"pushall","sequence_id":"20001"}})"));
+
+    broker.push_report("dev-1", R"({"print":{"command":"push_status","sequence_id":"20001","result":"success"}})");
+    std::string id, payload;
+    {
+        std::unique_lock<std::mutex> l(got_mutex);
+        REQUIRE(got_cv.wait_for(l, std::chrono::seconds(3), [&]{ return got_any; }));
+        id = got_id; payload = got_payload;
+    }
+    CHECK(id == "dev-1");
+    CHECK(payload.find("push_status") != std::string::npos);
+
+    // the client's command reached the broker on the request topic. The mock records
+    // the PUBLISH on its own read-loop thread, so poll rather than check immediately.
+    std::vector<std::string> reqs;
+    for (int i = 0; i < 200; ++i) {
+        reqs = broker.received_requests();
+        if (!reqs.empty()) break;
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+    REQUIRE(reqs.size() >= 1);
+    CHECK(reqs.front().find("pushall") != std::string::npos);
+    conn.stop();
+}
+
+TEST_CASE("OrcaMqtt round-trip — LAN-style config",   "[OrcaMqtt][.integration]") { run_round_trip(false); }
+TEST_CASE("OrcaMqtt round-trip — cloud-style config", "[OrcaMqtt][.integration]") { run_round_trip(true);  }
+
+TEST_CASE("OrcaMqtt keepalive runs while the connection is idle", "[OrcaMqtt][.integration]") {
+    orca_mqtt_test::MockBroker broker;
+    OrcaMqttConnection conn;
+    OrcaMqttConnection::Config cfg;
+    cfg.url = broker.ws_url();
+    cfg.keepalive_seconds = 2;
+
+    REQUIRE(conn.start(cfg, [](const std::string&, const std::string&) {}, [](bool, bool) {}));
+    for (int i = 0; i < 200 && broker.ping_count() == 0; ++i)
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    CHECK(broker.ping_count() > 0);
+    conn.stop();
+}
+
+TEST_CASE("OrcaMqtt reconnects and re-subscribes after a socket drop", "[OrcaMqtt][.integration]") {
+    orca_mqtt_test::MockBroker broker;
+    OrcaMqttConnection conn;
+    OrcaMqttConnection::Config cfg; cfg.url = broker.ws_url(); cfg.use_tls = false; cfg.username = "u"; cfg.password = "p";
+
+    std::mutex m; std::vector<std::string> got;
+    REQUIRE(conn.start(cfg,
+        [&](const std::string&, const std::string& p){ std::lock_guard<std::mutex> l(m); got.push_back(p); },
+        [](bool,bool){}));
+    REQUIRE(conn.subscribe("dev-1"));
+
+    broker.drop_client();
+    // the worker reconnects with ~1s backoff
+    for (int i = 0; i < 300 && broker.connect_count() < 2; ++i)
+        std::this_thread::sleep_for(std::chrono::milliseconds(20));
+    CHECK(broker.connect_count() >= 2);
+
+    // a report after the reconnect must still be delivered -> the SUBSCRIBE was re-sent
+    broker.push_report("dev-1", R"({"print":{"command":"push_status","sequence_id":"20002"}})");
+    bool delivered = false;
+    for (int i = 0; i < 200 && !delivered; ++i) {
+        { std::lock_guard<std::mutex> l(m); delivered = !got.empty(); }
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+    CHECK(delivered);
+    conn.stop();
+}
+
+TEST_CASE("OrcaMqtt auth rejection is terminal (no retry storm)", "[OrcaMqtt][.integration]") {
+    orca_mqtt_test::MockBroker broker(/*refuse_auth=*/true);
+    OrcaMqttConnection conn;
+    OrcaMqttConnection::Config cfg; cfg.url = broker.ws_url(); cfg.use_tls = false; cfg.username = "u"; cfg.password = "bad";
+
+    const bool ok = conn.start(cfg, [](const std::string&, const std::string&){}, [](bool,bool){});
+    CHECK_FALSE(ok);
+    CHECK(conn.last_connack_rc() == 5);
+    // worker must have stopped itself (rc 5 is terminal) — give it a moment
+    for (int i = 0; i < 100 && conn.is_running(); ++i)
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    CHECK_FALSE(conn.is_running());
+    // and it must NOT have hammered the broker with retries
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+    CHECK(broker.connect_count() <= 2);
+    conn.stop();
+}

tests/slic3rutils/test_orca_printer_agent.cpp

@@ -0,0 +1,572 @@
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_floating_point.hpp>
+#include <slic3r/GUI/FilamentMappingUtils.hpp>
+#include <slic3r/Utils/IPrinterAgent.hpp>
+#include <slic3r/Utils/OrcaCloudServiceAgent.hpp>
+#include <slic3r/Utils/OrcaPrinterAgent.hpp>
+
+#include "orca_mqtt_mock_broker.hpp"
+
+#include <chrono>
+#include <functional>
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+using Slic3r::OrcaPrinterAgent;
+
+namespace {
+// Probe exposes the protected internals the tests drive.
+struct Probe : OrcaPrinterAgent {
+    using OrcaPrinterAgent::OrcaPrinterAgent;
+    using OrcaPrinterAgent::deliver_to_sink;
+    using OrcaPrinterAgent::parse_lan_endpoint;
+    using OrcaPrinterAgent::make_lan_client_id;
+    using OrcaPrinterAgent::lan_connection_target;
+    using OrcaPrinterAgent::build_filament_mapping;
+    using OrcaPrinterAgent::build_gcode_file_payload;
+    using OrcaPrinterAgent::prepare_outgoing_request;
+    using OrcaPrinterAgent::parse_file_list;
+    using OrcaPrinterAgent::parse_thumbnail_path;
+    using OrcaPrinterAgent::encode_file_path;
+    using OrcaPrinterAgent::parse_file_metadata;
+};
+}
+
+TEST_CASE("OrcaPrinterAgent forwards a status payload to on_message_fn", "[OrcaPrinterAgent]") {
+    Probe agent("/tmp");
+    std::string got_id, got_payload;
+    agent.set_on_message_fn([&](std::string id, std::string p){ got_id = std::move(id); got_payload = std::move(p); });
+    agent.deliver_to_sink("dev-1", R"({"print":{"command":"push_status"}})", /*local=*/false);
+    CHECK(got_id == "dev-1");
+    CHECK(got_payload.find("push_status") != std::string::npos);
+}
+
+TEST_CASE("OrcaPrinterAgent stamps the get_capabilities nozzle diameter onto push_status frames", "[OrcaPrinterAgent]") {
+    Probe agent("/tmp");
+    std::string last_payload;
+    agent.set_on_message_fn([&](std::string, std::string p){ last_payload = std::move(p); });
+
+    // Before any capabilities reply, a push_status frame is forwarded untouched.
+    agent.deliver_to_sink("dev-1", R"({"print":{"command":"push_status","mc_percent":10}})", /*local=*/false);
+    CHECK(last_payload.find("nozzle_diameter") == std::string::npos);
+
+    // The get_capabilities reply is forwarded verbatim; its topology nozzle diameter
+    // is cached for the device.
+    agent.deliver_to_sink(
+        "dev-1",
+        R"({"info":{"command":"get_capabilities","capabilities":{"topology":{"tools":[{"id":"T0","nozzle":{"diameter_mm":0.4}}]}}}})",
+        /*local=*/false);
+    CHECK(last_payload.find("\"command\":\"get_capabilities\"") != std::string::npos);
+    CHECK(last_payload.find("\"print\"") == std::string::npos);
+
+    // Later push_status frames for that device get the cached diameter plus a neutral
+    // nozzle_type, so MachineObject::parse_json's legacy nozzle parser can run.
+    agent.deliver_to_sink("dev-1", R"({"print":{"command":"push_status","mc_percent":20}})", /*local=*/false);
+    CHECK(last_payload.find("\"nozzle_diameter\":0.4") != std::string::npos);
+    CHECK(last_payload.find("\"nozzle_type\":\"N/A\"") != std::string::npos);
+
+    // A different device is unaffected.
+    agent.deliver_to_sink("dev-2", R"({"print":{"command":"push_status"}})", /*local=*/false);
+    CHECK(last_payload.find("nozzle_diameter") == std::string::npos);
+
+    // A frame that already carries real nozzle data is not overridden.
+    agent.deliver_to_sink("dev-1", R"({"print":{"command":"push_status","nozzle_diameter":0.6}})", /*local=*/false);
+    CHECK(last_payload.find("\"nozzle_diameter\":0.6") != std::string::npos);
+    CHECK(last_payload.find("N/A") == std::string::npos);
+}
+
+TEST_CASE("OrcaPrinterAgent owns connector capabilities and fails closed for AMS commands", "[OrcaPrinterAgent]") {
+    Probe agent("/tmp");
+    agent.deliver_to_sink("orca-caps", R"({
+        "info": {
+            "command": "get_capabilities",
+            "supported_features": {"fms": true, "filament_slots": true, "filament_mapping": true},
+            "supported_commands": ["print.ams_get_rfid"],
+            "capabilities": {
+                "protocol": {
+                    "features": {"filament_mapping": true},
+                    "supported_commands": ["print.ams_change_filament"]
+                }
+            }
+        }
+    })", false);
+
+    CHECK(agent.supports_feature("orca-caps", "filament_mapping"));
+    CHECK(agent.supports_command("orca-caps", "print.ams_filament_setting"));
+    CHECK(agent.supports_command("orca-caps", "print.ams_change_filament"));
+    CHECK(agent.supports_command("orca-caps", "print.ams_get_rfid"));
+    CHECK_FALSE(agent.supports_command("orca-caps", "print.ams_control"));
+
+    agent.deliver_to_sink("orca-caps", R"({
+        "info": {
+            "command": "get_capabilities",
+            "supported_features": {"fms": false, "filament_slots": false, "filament_mapping": false},
+            "supported_commands": ["print.ams_control"],
+            "capabilities": {"protocol": {"features": {}, "supported_commands": []}}
+        }
+    })", false);
+
+    CHECK_FALSE(agent.supports_feature("orca-caps", "filament_mapping"));
+    CHECK_FALSE(agent.supports_command("orca-caps", "print.ams_filament_setting"));
+    CHECK_FALSE(agent.supports_command("orca-caps", "print.ams_change_filament"));
+    CHECK_FALSE(agent.supports_command("orca-caps", "print.ams_control"));
+    CHECK_FALSE(agent.supports_command("orca-caps", "print.ams_calibrate"));
+    CHECK(agent.supports_command("orca-caps", "print.gcode_file"));
+}
+
+TEST_CASE("OrcaPrinterAgent clears cached capabilities when a device is unbound", "[OrcaPrinterAgent]") {
+    Probe agent("/tmp");
+    agent.deliver_to_sink("orca-forget", R"({
+        "info": {
+            "command": "get_capabilities",
+            "supported_features": {"filament_slots": true},
+            "supported_commands": [],
+            "capabilities": {"protocol": {"features": {}, "supported_commands": []}}
+        }
+    })", false);
+    REQUIRE(agent.supports_command("orca-forget", "print.ams_filament_setting"));
+
+    agent.unbind("orca-forget");
+    CHECK_FALSE(agent.supports_command("orca-forget", "print.ams_filament_setting"));
+}
+
+TEST_CASE("OrcaPrinterAgent removes setting_id from AMS metadata and gates the request", "[OrcaPrinterAgent]") {
+    Probe agent("/tmp");
+    agent.deliver_to_sink("orca-ams-write", R"({
+        "info": {
+            "command": "get_capabilities",
+            "supported_features": {"fms": false, "filament_slots": true},
+            "supported_commands": [],
+            "capabilities": {"protocol": {"features": {"filament_slots": true}, "supported_commands": []}}
+        }
+    })", false);
+
+    const std::string request = R"({"print":{"command":"ams_filament_setting","sequence_id":"9","tray_info_idx":"GFL99","setting_id":"preset-setting"}})";
+    std::string command;
+    std::string prepared;
+    CHECK(agent.prepare_outgoing_request("orca-ams-write", request, command, prepared) == BAMBU_NETWORK_SUCCESS);
+    CHECK(command == "print.ams_filament_setting");
+    const nlohmann::json parsed = nlohmann::json::parse(prepared);
+    CHECK_FALSE(parsed["print"].contains("setting_id"));
+    CHECK(parsed["print"]["tray_info_idx"] == "GFL99");
+
+    agent.deliver_to_sink("orca-ams-write", R"({
+        "info": {
+            "command": "get_capabilities",
+            "supported_features": {"filament_slots": false},
+            "capabilities": {"protocol": {"features": {"filament_slots": false}}}
+        }
+    })", false);
+    CHECK(agent.prepare_outgoing_request("orca-ams-write", request, command, prepared) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_lan_endpoint", "[OrcaPrinterAgent]") {
+    std::string h, p;
+    REQUIRE(Probe::parse_lan_endpoint("192.168.1.9", h, p));
+    CHECK(h == "192.168.1.9"); CHECK(p == "8280");
+    REQUIRE(Probe::parse_lan_endpoint("http://host.local:9000/x", h, p));
+    CHECK(h == "host.local"); CHECK(p == "9000");
+    CHECK_FALSE(Probe::parse_lan_endpoint("", h, p));
+}
+
+TEST_CASE("OrcaPrinterAgent::make_lan_client_id is stable and prefixed", "[OrcaPrinterAgent]") {
+    const auto a = Probe::make_lan_client_id("dev-1");
+    const auto b = Probe::make_lan_client_id("dev-1");
+    CHECK(a == b);                                   // drawn once per process
+    CHECK(a.rfind("orcaslicer-lan-dev-1-", 0) == 0);
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_file_list normalizes Moonraker entries", "[OrcaPrinterAgent]") {
+    const std::vector<Slic3r::PrinterFileEntry> files = Probe::parse_file_list(R"({
+        "result": [
+            {"path": "sub/foo.gcode", "modified": 1700000000.75, "size": 1234, "permissions": "rw"},
+            {"path": "bar.gcode", "modified": 42, "size": 7}
+        ]
+    })");
+    REQUIRE(files.size() == 2);
+    CHECK(files[0].path == "sub/foo.gcode");
+    CHECK(files[0].name == "foo.gcode");
+    CHECK(files[0].size == 1234);
+    CHECK(files[0].modified == 1700000000);   // fractional seconds truncate
+    CHECK(files[1].path == "bar.gcode");
+    CHECK(files[1].name == "bar.gcode");
+    CHECK(files[1].size == 7);
+    CHECK(files[1].modified == 42);
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_file_list handles an empty result", "[OrcaPrinterAgent]") {
+    CHECK(Probe::parse_file_list(R"({"result": []})").empty());
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_file_list rejects malformed JSON", "[OrcaPrinterAgent]") {
+    CHECK(Probe::parse_file_list("not json").empty());
+    CHECK(Probe::parse_file_list(R"({"result": "nope"})").empty());
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_file_list skips entries missing fields", "[OrcaPrinterAgent]") {
+    const std::vector<Slic3r::PrinterFileEntry> files = Probe::parse_file_list(R"({
+        "result": [
+            {"size": 5},
+            {"path": ""},
+            {"path": "kept.gcode"},
+            "not-an-object"
+        ]
+    })");
+    REQUIRE(files.size() == 1);
+    CHECK(files[0].path == "kept.gcode");
+    CHECK(files[0].name == "kept.gcode");
+    CHECK(files[0].size == 0);
+    CHECK(files[0].modified == 0);
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_thumbnail_path picks the largest width", "[OrcaPrinterAgent]") {
+    const std::string path = Probe::parse_thumbnail_path(R"({
+        "result": [
+            {"width": 32, "height": 32, "thumbnail_path": ".thumbs/foo.gcode-32x32.png"},
+            {"width": 300, "height": 300, "thumbnail_path": ".thumbs/foo.gcode-300x300.png"},
+            {"width": 100, "height": 100, "thumbnail_path": ".thumbs/foo.gcode-100x100.png"}
+        ]
+    })");
+    CHECK(path == ".thumbs/foo.gcode-300x300.png");
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_thumbnail_path accepts both key spellings", "[OrcaPrinterAgent]") {
+    CHECK(Probe::parse_thumbnail_path(R"({"result": [{"width": 32, "relative_path": ".thumbs/old.png"}]})") == ".thumbs/old.png");
+    CHECK(Probe::parse_thumbnail_path(R"({"result": [{"width": 32, "thumbnail_path": ".thumbs/new.png"}]})") == ".thumbs/new.png");
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_thumbnail_path handles an empty result", "[OrcaPrinterAgent]") {
+    CHECK(Probe::parse_thumbnail_path(R"({"result": []})").empty());
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_thumbnail_path rejects malformed JSON", "[OrcaPrinterAgent]") {
+    CHECK(Probe::parse_thumbnail_path("not json").empty());
+    CHECK(Probe::parse_thumbnail_path(R"({"result": "nope"})").empty());
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_thumbnail_path skips an entry without a path", "[OrcaPrinterAgent]") {
+    CHECK(Probe::parse_thumbnail_path(R"({"result": [{"width": 300, "height": 300}]})").empty());
+    CHECK(Probe::parse_thumbnail_path(R"({"result": [{"width": 300, "thumbnail_path": 7}]})").empty());
+}
+
+TEST_CASE("OrcaPrinterAgent::encode_file_path preserves separators and encodes segments", "[OrcaPrinterAgent]") {
+    CHECK(Probe::encode_file_path("foo.gcode") == "foo.gcode");                          // flat path
+    CHECK(Probe::encode_file_path("sub/foo.gcode") == "sub/foo.gcode");                  // '/' kept as separator
+    CHECK(Probe::encode_file_path("a/b/c.gcode") == "a/b/c.gcode");
+    CHECK(Probe::encode_file_path("sub dir/my file #1.gcode") == "sub%20dir/my%20file%20%231.gcode");
+    CHECK(Probe::encode_file_path("design+part.gcode") == "design%2Bpart.gcode");
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_file_metadata parses the Moonraker fields", "[OrcaPrinterAgent]") {
+    using Catch::Matchers::WithinAbs;
+    const Slic3r::PrinterFileMetadata meta = Probe::parse_file_metadata(R"({
+        "result": {
+            "filename": "sub/foo.gcode",
+            "size": 1234,
+            "modified": 1700000000.5,
+            "estimated_time": 3725,
+            "filament_total": 10500.5,
+            "filament_weight_total": 31.6,
+            "thumbnails": []
+        }
+    })");
+    CHECK(meta.estimated_time == 3725);
+    CHECK_THAT(meta.filament_total, WithinAbs(10500.5, 1e-9));
+    CHECK_THAT(meta.filament_weight, WithinAbs(31.6, 1e-9));
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_file_metadata defaults missing fields to zero", "[OrcaPrinterAgent]") {
+    using Catch::Matchers::WithinAbs;
+    const Slic3r::PrinterFileMetadata meta = Probe::parse_file_metadata(R"({"result": {"filename": "foo.gcode"}})");
+    CHECK(meta.estimated_time == 0);
+    CHECK_THAT(meta.filament_total, WithinAbs(0.0, 1e-12));
+    CHECK_THAT(meta.filament_weight, WithinAbs(0.0, 1e-12));
+}
+
+TEST_CASE("OrcaPrinterAgent::parse_file_metadata yields zeros for a malformed reply", "[OrcaPrinterAgent]") {
+    using Catch::Matchers::WithinAbs;
+    const Slic3r::PrinterFileMetadata malformed = Probe::parse_file_metadata("not json");
+    CHECK(malformed.estimated_time == 0);
+    CHECK_THAT(malformed.filament_total, WithinAbs(0.0, 1e-12));
+    CHECK_THAT(malformed.filament_weight, WithinAbs(0.0, 1e-12));
+
+    const Slic3r::PrinterFileMetadata wrong_type = Probe::parse_file_metadata(R"({"result": "nope"})");
+    CHECK(wrong_type.estimated_time == 0);
+    CHECK_THAT(wrong_type.filament_total, WithinAbs(0.0, 1e-12));
+}
+
+TEST_CASE("filament mapping is keyed by the ams_mapping2 array position", "[OrcaPrinterAgent]") {
+    const nlohmann::json mapping = Probe::build_filament_mapping(
+        R"([{"ams_id":1,"slot_id":5},{"ams_id":255,"slot_id":255},{"ams_id":255,"slot_id":0}])");
+    REQUIRE(mapping.is_array());
+    REQUIRE(mapping.size() == 2);
+    CHECK(mapping[0]["filament_index"] == 0);
+    CHECK(mapping[0]["ams_id"] == 1);
+    CHECK(mapping[0]["slot_id"] == 5);
+    // The unmatched middle entry is dropped; the third entry keeps index 2.
+    CHECK(mapping[1]["filament_index"] == 2);
+    CHECK(mapping[1]["ams_id"] == 255);
+    CHECK(mapping[1]["slot_id"] == 0);
+}
+
+// Index-correlation merge gate (plan PR 3). `ams_mapping2` is built one entry
+// per logical filament, so its array position is the identifier the generated
+// G-code toolchange passes to the Klipper macro (`next_filament_id`). The
+// serializer must key `filament_index` by that position and must never
+// re-densify after dropping unused/sentinel entries, or a used filament would
+// be aimed at the wrong lane. This test covers the plan's matrix: preset order
+// differing from used order, a middle filament unused, and external slots.
+TEST_CASE("filament mapping index correlates with the ams_mapping2 position", "[OrcaPrinterAgent]") {
+    // Positions 0..4. Used filaments are 0, 2 and 4; 1 and 3 are unused.
+    const nlohmann::json mapping = Probe::build_filament_mapping(
+        R"([{"ams_id":0,"slot_id":1},{"ams_id":255,"slot_id":255},{"ams_id":2,"slot_id":3},{"ams_id":255,"slot_id":255},{"ams_id":255,"slot_id":0}])");
+    REQUIRE(mapping.size() == 3);
+    CHECK(mapping[0]["filament_index"] == 0);
+    CHECK(mapping[1]["filament_index"] == 2);
+    CHECK(mapping[2]["filament_index"] == 4); // external slot keeps its position
+    CHECK(mapping[2]["ams_id"] == 255);
+    CHECK(mapping[2]["slot_id"] == 0);
+    // No re-densification: a used filament after a dropped sentinel keeps its
+    // original logical index.
+    for (const auto& entry : mapping)
+        CHECK(entry.contains("filament_index"));
+}
+
+TEST_CASE("filament mapping is omitted when nothing remains", "[OrcaPrinterAgent]") {
+    CHECK(Probe::build_filament_mapping("").empty());
+    CHECK(Probe::build_filament_mapping(R"([{"ams_id":255,"slot_id":255}])").empty());
+    CHECK(Probe::build_filament_mapping("not json").empty());
+    CHECK(Probe::build_filament_mapping(R"({"ams_id":1,"slot_id":0})").empty()); // not an array
+}
+
+// The GUI capability gate and the agent serializer must classify the same
+// entries as engaged. External slots ({255,0}/{254,0}) are normalized as-is, so
+// they engage; only the {255,255} unmatched sentinel is dropped. A mismatch lets
+// an entry past the GUI and refused late with a generic publish error.
+TEST_CASE("the GUI mapping gate engages exactly the entries the serializer sends", "[OrcaPrinterAgent]") {
+    using Slic3r::GUI::has_engaged_filament_mapping;
+    CHECK_FALSE(has_engaged_filament_mapping(""));
+    CHECK_FALSE(has_engaged_filament_mapping("[]"));
+    CHECK_FALSE(has_engaged_filament_mapping("not json"));
+    CHECK_FALSE(has_engaged_filament_mapping(R"([{"ams_id":255,"slot_id":255}])"));
+    CHECK(has_engaged_filament_mapping(R"([{"ams_id":255,"slot_id":0}])"));   // external main
+    CHECK(has_engaged_filament_mapping(R"([{"ams_id":254,"slot_id":0}])"));   // external deputy
+    CHECK(has_engaged_filament_mapping(R"([{"ams_id":0,"slot_id":0}])"));     // box slot
+    CHECK(has_engaged_filament_mapping(R"([{"ams_id":255,"slot_id":255},{"ams_id":1,"slot_id":2}])"));
+
+    for (const char* s : {"", "[]", "not json", R"([{"ams_id":255,"slot_id":255}])",
+                          R"([{"ams_id":255,"slot_id":0}])", R"([{"ams_id":254,"slot_id":0}])",
+                          R"([{"ams_id":0,"slot_id":0}])",
+                          R"([{"ams_id":255,"slot_id":255},{"ams_id":1,"slot_id":2}])"}) {
+        CHECK(has_engaged_filament_mapping(s) == !Probe::build_filament_mapping(s).empty());
+    }
+}
+
+// The used-unmapped refusal reads m_ams_mapping_result: an entry with no target carries
+// empty ams_id/slot_id, while an external-spool assignment (ams_id 255/254) is a real
+// target. A wholly unmapped print reports no target and falls to the existing send flow.
+TEST_CASE("used-filament targets split mapped from unmapped", "[OrcaPrinterAgent]") {
+    using Slic3r::GUI::has_any_mapped_target;
+    using Slic3r::GUI::has_used_filament_without_target;
+
+    Slic3r::FilamentInfo box;      box.ams_id      = "0";   box.slot_id = "1";   // box slot
+    Slic3r::FilamentInfo external; external.ams_id = "255"; external.slot_id = "0"; // external spool
+    Slic3r::FilamentInfo unmapped;                                                // no target
+
+    CHECK_FALSE(has_used_filament_without_target({box, external}));
+    CHECK(has_used_filament_without_target({box, unmapped}));
+    CHECK(has_used_filament_without_target({external, unmapped}));
+    CHECK(has_used_filament_without_target({unmapped}));   // wholly unmapped: all-invalid flow, not this refusal
+    CHECK(has_any_mapped_target({box, unmapped}));
+    CHECK(has_any_mapped_target({external, unmapped}));
+    CHECK_FALSE(has_any_mapped_target({unmapped}));
+}
+
+// A device with no AMS units has one source, the external spool. OrcaSlicer's
+// auto-mapping force-selects it for every filament; that is not a lane choice, so it
+// must not gate the print or reach print.gcode_file.
+TEST_CASE("a no-AMS device drops the forced external-spool selection", "[OrcaPrinterAgent]") {
+    using Slic3r::GUI::drop_forced_external_selection;
+    using Slic3r::GUI::has_engaged_filament_mapping;
+
+    std::string external_only = R"([{"ams_id":255,"slot_id":0}])";
+    drop_forced_external_selection(/*device_has_ams=*/false, external_only);
+    CHECK(external_only.empty());
+    CHECK_FALSE(has_engaged_filament_mapping(external_only));
+    CHECK(Probe::build_filament_mapping(external_only).empty());
+
+    std::string box_mapping = R"([{"ams_id":0,"slot_id":2}])";
+    drop_forced_external_selection(/*device_has_ams=*/true, box_mapping);
+    CHECK(box_mapping == R"([{"ams_id":0,"slot_id":2}])");
+    CHECK(has_engaged_filament_mapping(box_mapping));
+}
+
+// An empty mapping must leave the gcode_file payload byte-identical to today:
+// exactly command, sequence_id and param, with no filament_mapping key.
+TEST_CASE("gcode_file payload omits filament_mapping when the map is empty", "[OrcaPrinterAgent]") {
+    const nlohmann::json empty = Probe::build_gcode_file_payload("7", "job.gcode", nlohmann::json::array());
+    REQUIRE(empty.contains("print"));
+    CHECK(empty["print"].size() == 3);
+    CHECK(empty["print"]["command"] == "gcode_file");
+    CHECK(empty["print"]["sequence_id"] == "7");
+    CHECK(empty["print"]["param"] == "job.gcode");
+    CHECK_FALSE(empty["print"].contains("filament_mapping"));
+
+    const nlohmann::json mapping = Probe::build_filament_mapping(R"([{"ams_id":1,"slot_id":0},{"ams_id":255,"slot_id":255}])");
+    const nlohmann::json with    = Probe::build_gcode_file_payload("8", "job.gcode", mapping);
+    REQUIRE(with["print"].contains("filament_mapping"));
+    REQUIRE(with["print"]["filament_mapping"].size() == 1);
+    CHECK(with["print"]["filament_mapping"][0]["filament_index"] == 0);
+}
+
+// The defensive gate: a mapped print is refused before anything is published when the
+// connector never advertised filament_mapping. The GUI send gates make this visible first;
+// this covers callers that bypass them (calibration, plugin). A sentinel-only mapping does
+// not engage the gate and falls through to the normal publish path.
+TEST_CASE("an engaged mapping is refused when the connector never advertised filament_mapping", "[OrcaPrinterAgent]") {
+    OrcaPrinterAgent agent("/tmp");
+    Slic3r::PrintParams params;
+    params.dev_id       = "dev-no-mapping-cap";
+    params.dst_file     = "/tmp/job.gcode";
+    params.ams_mapping2 = R"([{"ams_id":0,"slot_id":2}])";
+
+    CHECK(agent.start_sdcard_print(params, {}, {}) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+
+    params.ams_mapping2 = R"([{"ams_id":255,"slot_id":255}])";
+    CHECK(agent.start_sdcard_print(params, {}, {}) == BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED);
+}
+
+// The FTP "send with record" transport does not exist on OrcaSonar. It must
+// report a non-success result so PrintJob falls back to start_print() rather
+// than treating a print that was never sent as successful.
+TEST_CASE("start_local_print_with_record never reports silent success", "[OrcaPrinterAgent]") {
+    Probe agent("/tmp");
+    Slic3r::PrintParams params;
+    const int rc = agent.start_local_print_with_record(params, {}, {}, {});
+    CHECK(rc < 0);
+}
+
+TEST_CASE("connect_printer wires up a LAN Config", "[OrcaPrinterAgent][.integration]") {
+    Probe agent("/tmp");
+    Slic3r::PrinterConnectionParams params{
+        "dev-1", "10.255.255.1", "orcasonar", "code", "", false, ""
+    };
+    const int rc = agent.connect_printer(params);
+    CHECK(rc == BAMBU_NETWORK_SUCCESS);
+    CHECK(agent.lan_connection_target() == "ws://10.255.255.1:8280/mqtt");
+    CHECK(agent.get_user_selected_machine().empty());   // LAN path must not touch the cloud selection
+    agent.disconnect_printer();
+}
+
+TEST_CASE("post-connect sequence is subscribe then 4 requests in order", "[OrcaPrinterAgent]") {
+    struct SeqProbe : OrcaPrinterAgent {
+        using OrcaPrinterAgent::OrcaPrinterAgent;
+        std::vector<std::string> calls;
+        void emit_connect_sequence(const std::string& dev_id,
+            std::function<void(const std::string&)> /*sub*/,
+            std::function<void(const std::string&)> /*req*/) override {
+            OrcaPrinterAgent::emit_connect_sequence(dev_id,
+                [&](const std::string& id){ calls.push_back("sub:" + id); },
+                [&](const std::string& body){ calls.push_back(body); });
+        }
+    } probe("/tmp");
+    probe.run_connect_sequence_for_test("dev-1");
+    REQUIRE(probe.calls.size() == 5);
+    CHECK(probe.calls[0] == "sub:dev-1");
+    CHECK(probe.calls[1].find("\"pushing\"") != std::string::npos);
+    CHECK(probe.calls[1].find("\"start\"")   != std::string::npos);
+    CHECK(probe.calls[2].find("pushall")     != std::string::npos);
+    CHECK(probe.calls[3].find("get_version") != std::string::npos);
+    CHECK(probe.calls[4].find("get_capabilities") != std::string::npos);
+    for (auto& c : probe.calls)
+        if (auto pos = c.find("sequence_id"); pos != std::string::npos)
+            CHECK(c.substr(pos).find("\"2") != std::string::npos);
+}
+
+// Hidden: spawns the connect worker and attempts a real (failing) connect.
+TEST_CASE("selecting a cloud printer configures the fleet socket", "[OrcaPrinterAgent][.integration]") {
+    auto cloud = std::make_shared<Slic3r::OrcaCloudServiceAgent>("/tmp");
+    cloud->set_api_base_url("api.example.com");
+    OrcaPrinterAgent agent("/tmp");
+    agent.set_cloud_agent(cloud);
+
+    agent.set_user_selected_machine("printer-uuid-1");
+    // The configure runs on the connect worker; poll rather than racing it.
+    std::string url;
+    for (int i = 0; i < 300; ++i) {
+        url = cloud->selected_printer_mqtt_url();
+        if (!url.empty()) break;
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+    CHECK(url == "wss://api.example.com/api/v1/printers/mqtt");
+
+    agent.set_user_selected_machine("");     // selection changes do not tear down the fleet socket
+    CHECK(cloud->selected_printer_mqtt_url() == "wss://api.example.com/api/v1/printers/mqtt");
+}
+
+TEST_CASE("a stale-generation inbound message is dropped", "[OrcaPrinterAgent]") {
+    struct GenProbe : OrcaPrinterAgent {
+        using OrcaPrinterAgent::OrcaPrinterAgent;
+        using OrcaPrinterAgent::make_lan_message_handler;   // expose for the test
+    };
+    GenProbe agent("/tmp");
+    int hits = 0;
+    agent.set_on_message_fn([&](std::string, std::string){ ++hits; });
+    auto handler_gen1 = agent.make_lan_message_handler(/*generation=*/1);
+    // m_lan_generation starts at 0; two bumps -> 2, so the epoch-1 handler is stale.
+    agent.bump_lan_generation_for_test();
+    agent.bump_lan_generation_for_test();
+    handler_gen1("dev-1", "{}");                            // late callback from gen 1
+    CHECK(hits == 0);
+}
+
+TEST_CASE("connect_server does not start an MQTT socket", "[OrcaCloud]") {
+    auto cloud = std::make_shared<Slic3r::OrcaCloudServiceAgent>("/tmp");
+    cloud->set_api_base_url("127.0.0.1:1");     // no session -> connect_server short-circuits before any probe
+    cloud->connect_server();
+    REQUIRE(cloud->get_mqtt_connection() != nullptr);       // created in the ctor
+    CHECK_FALSE(cloud->get_mqtt_connection()->is_running()); // never started
+    CHECK(cloud->selected_printer_mqtt_url().empty());
+}
+
+TEST_CASE("send_message* reject when there is no connection", "[OrcaPrinterAgent]") {
+    OrcaPrinterAgent agent("/tmp");   // no cloud agent, no LAN connection
+    CHECK(agent.send_message("d", "{}", 0, 0)            == BAMBU_NETWORK_ERR_INVALID_HANDLE);
+    CHECK(agent.send_message_to_printer("d", "{}", 0, 0) == BAMBU_NETWORK_ERR_INVALID_HANDLE);
+    CHECK(agent.send_message("", "{}", 0, 0)             == BAMBU_NETWORK_ERR_INVALID_HANDLE);   // empty dev_id
+}
+
+TEST_CASE("send_message_to_printer publishes on the LAN connection", "[OrcaPrinterAgent][.integration]") {
+    orca_mqtt_test::MockBroker broker;
+    OrcaPrinterAgent agent("/tmp");
+    const auto ep = broker.host_port();
+    agent.connect_printer(Slic3r::PrinterConnectionParams{"dev-1", ep.first + ":" + ep.second, "orcasonar", "code", "", false, ""});
+
+    for (int i = 0; i < 150 && broker.connect_count() == 0; ++i)
+        std::this_thread::sleep_for(std::chrono::milliseconds(20));
+    REQUIRE(broker.connect_count() >= 1);
+
+    CHECK(agent.send_message_to_printer("dev-1", R"({"print":{"command":"pause","sequence_id":"20007"}})", 0, 0)
+          == BAMBU_NETWORK_SUCCESS);
+
+    // on_connected also publishes 4 requests; poll until "pause" specifically shows up.
+    bool saw_pause = false;
+    for (int i = 0; i < 150 && !saw_pause; ++i) {
+        for (const auto& r : broker.received_requests())
+            if (r.find("pause") != std::string::npos) { saw_pause = true; break; }
+        std::this_thread::sleep_for(std::chrono::milliseconds(20));
+    }
+    CHECK(saw_pause);
+    agent.disconnect_printer();
+}
+
+TEST_CASE("destroying an agent mid-connect does not hang or crash", "[OrcaPrinterAgent]") {
+    for (int i = 0; i < 20; ++i) {
+        auto agent = std::make_unique<OrcaPrinterAgent>("/tmp");
+        agent->connect_printer(Slic3r::PrinterConnectionParams{"dev-1", "127.0.0.1:1", "orcasonar", "code", "", false, ""});  // nothing listening: instant ECONNREFUSED
+        agent.reset();   // ~OrcaPrinterAgent must stop the conn, join the thread, and not hang/crash
+    }
+    SUCCEED();
+}

tests/slic3rutils/test_printer_agent.cpp

@@ -1,7 +1,5 @@
 #include <catch2/catch_all.hpp>
 
-#include <slic3r/Utils/BBLPrinterAgent.hpp>
-#include <slic3r/Utils/MoonrakerPrinterAgent.hpp>
 #include <memory>
 #include "slic3r/Utils/ICloudServiceAgent.hpp"
 #include "slic3r/Utils/IPrinterAgent.hpp"
@@ -16,155 +14,11 @@
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>
 
-#include <atomic>
-#include <chrono>
-#include <future>
 #include <string>
-#include <thread>
 
 using namespace Slic3r;
 namespace py = pybind11;
 
-class MoonrakerParserProbe : public MoonrakerPrinterAgent
-{
-public:
-    using MoonrakerPrinterAgent::parse_nozzle_diameter;
-
-    explicit MoonrakerParserProbe(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-};
-
-TEST_CASE("Moonraker parses nozzle diameter from configfile settings", "[unit][moonraker]")
-{
-    const auto response = nlohmann::json::parse(R"({
-        "result": {
-            "status": {
-                "configfile": {
-                    "settings": {
-                        "extruder": {
-                            "nozzle_diameter": 0.6
-                        }
-                    }
-                }
-            }
-        }
-    })");
-
-    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(response) == Catch::Approx(0.6f));
-}
-
-TEST_CASE("Moonraker parses nozzle diameter from raw config and tolerates missing data", "[unit][moonraker]")
-{
-    const auto raw_config_response = nlohmann::json::parse(R"({
-        "result": {
-            "status": {
-                "configfile": {
-                    "config": {
-                        "extruder": {
-                            "nozzle_diameter": "0.8"
-                        }
-                    }
-                }
-            }
-        }
-    })");
-    const auto missing_response = nlohmann::json::object();
-
-    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(raw_config_response) == Catch::Approx(0.8f));
-    CHECK(MoonrakerParserProbe::parse_nozzle_diameter(missing_response) == 0.0f);
-}
-
-// why: an agent without a Bambu-dialect translation must refuse these commands before any network or wx path.
-TEST_CASE("unit: default AMS commands report not supported", "[unit][moonraker]")
-{
-    MoonrakerPrinterAgent agent("");
-
-    CHECK(agent.command_ams_refresh_rfid("dev", 123, 1, 0, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.command_ams_calibrate("dev", 1, 2, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.command_ams_select_tray("dev", "123", 3, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-}
-
-TEST_CASE("unit: Moonraker light name matching", "[unit][moonraker]")
-{
-    CHECK(moonraker_is_light_name("caselight"));
-    CHECK(moonraker_is_light_name("LED_STRIP"));
-    CHECK_FALSE(moonraker_is_light_name("beeper"));
-    CHECK(moonraker_is_light_name("FLASHLIGHT_SWITCH"));
-    CHECK(moonraker_is_light_name("MODLELIGHT_SWITCH"));
-}
-
-// ===========================================================================
-// UNIT - handle_request's not-supported default.
-// The agent is the only thing that knows what it can translate, so an untranslated
-// command has to say so instead of returning success and letting the UI believe the
-// control worked. Guards the inverse too: the pushing namespace is genuinely
-// satisfied by the websocket status stream, and it re-fires from the keepalive timer
-// roughly once a second, so it must stay a success or it would raise a dialog on a
-// timer. Only branches that touch neither the network nor wx are exercised.
-// ===========================================================================
-TEST_CASE("unit: Moonraker reports untranslated commands as not supported", "[unit][moonraker]")
-{
-    MoonrakerPrinterAgent agent("");
-
-    CHECK(agent.send_message("dev", R"({"print":{"command":"ams_change_filament"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.send_message("dev", R"({"system":{"command":"set_door_stat"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-    CHECK(agent.send_message("dev", R"({"xcam":{"command":"xcam_control_set"}})", 0, 0) ==
-          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
-
-    CHECK(agent.send_message("dev", R"({"pushing":{"command":"pushall"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
-    CHECK(agent.send_message("dev", R"({"pushing":{"command":"start"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
-
-    // why: malformed input is a different failure than an untranslated command, and the
-    // default must not swallow it into a misleading not-supported verdict.
-    CHECK(agent.send_message("dev", "{not json", 0, 0) == BAMBU_NETWORK_ERR_INVALID_RESULT);
-}
-
-// why: IPrinterAgent::fetch_filament_info is the single virtual hook derived agents override
-// (MoonrakerPrinterAgent's own override is synchronous, but QidiPrinterAgent's override is
-// fire-and-forget: it spawns a detached thread and returns immediately). QidiPrinterAgent is
-// `final`, so this probes the same contract with a controllable double instead.
-TEST_CASE("unit: a fire-and-forget override of fetch_filament_info is not waited on by the caller",
-          "[unit][moonraker]")
-{
-    class RecordingAgent : public Slic3r::MoonrakerPrinterAgent
-    {
-    public:
-        explicit RecordingAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
-
-        std::atomic<bool>  invoked{false};
-        std::promise<void> release_gate;
-        std::promise<void> done_promise;
-
-        bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode /*sync_mode*/ = FilamentSyncMode::pull) override
-        {
-            std::thread([this]() {
-                invoked.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.get_future().wait();
-                done_promise.set_value();
-            }).detach();
-            return true;
-        }
-    };
-
-    auto agent = std::make_shared<RecordingAgent>(std::string{});
-    auto done_future = agent->done_promise.get_future();
-
-    bool immediate_result = agent->fetch_filament_info("test-dev");
-
-    // fetch_filament_info must return before its background work completes — prove
-    // it by confirming the background call is still blocked on the gate right now.
-    REQUIRE(immediate_result == true);
-    REQUIRE(done_future.wait_for(std::chrono::milliseconds(100)) == std::future_status::timeout);
-
-    // Now let the background call finish and confirm it actually ran (polymorphic dispatch).
-    agent->release_gate.set_value();
-    REQUIRE(done_future.wait_for(std::chrono::seconds(2)) == std::future_status::ready);
-    REQUIRE(agent->invoked.load() == true);
-}
-
 // ===========================================================================
 // UNIT - printer-agent registry duplicate handling.
 // Confirms a duplicate agent id is rejected so a plugin cannot shadow a built-in

tests/slic3rutils/test_qidi_printer_agent.cpp

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