Move the G-code processing result instead of copying it

GCodeProcessorResult declares a copy assignment, which suppresses the implicit move assignment, so `*result = std::move(processor.extract_result())` binds to the copy and duplicates the whole moves array: 96 bytes per move, measured at 147.7 MiB in one allocation for a 597k facet model at 0.08 mm, with the source staying alive until the export returns. Add the move assignment. It assigns exactly the same 39 members in the same order as the copy, including the ones the copy deliberately leaves alone, so a target that carries its own filament maps and nozzle type keeps them. A move constructor is intentionally not added: the type holds a std::mutex, so it is neither copy nor move constructible today and a partial one would leave ten members uninitialised. reset() now releases the two print sized vectors rather than clearing them. Its callers are the paths that discard a result, so the memory went back only at the next slice. ViewerImpl::reset() does the same for the two vectors sized by the print, which is what keeps a discarded preview resident, and counts m_vertices_colors in the reported CPU memory, where it was missing.
2026-10-02 13:20:59 +00:00 · 2026-10-01 09:15:15 +02:00
38 changed files with 473 additions and 6365 deletions
@@ -151,12 +151,6 @@ elseif(APPLE)
    # the post-install -add_rpath below.
    set(_python_ldflags "${_python_arch_flags} -Wl,-headerpad_max_install_names")

-    # The macOS 27 SDK declares pipe2() and dup3() as available from macOS 27, so
-    # configure finds them and CPython 3.12 calls them without a runtime check.
-    # Below a macOS 27 deployment target they are weak-linked and resolve to NULL
-    # on older systems, where os.pipe() then segfaults -- in `make install`
-    # (compileall, ensurepip) and in the shipped app alike. Every configure below
-    # keeps the pipe()/dup2() fallbacks (python/cpython#153711).
    if(IS_CROSS_COMPILE)
        set(_python_build_tgt --build=${_python_build_arch}-apple-darwin --host=${_python_host_arch}-apple-darwin)
        set(_python_build_arch_flags "-arch ${_python_build_arch_flag} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
@@ -180,8 +174,7 @@ elseif(APPLE)
                 --enable-shared \
                 --without-static-libpython \
                 --disable-test-modules \
-                 --build=${_python_build_arch}-apple-darwin \
-                 ac_cv_func_pipe2=no ac_cv_func_dup3=no && \
+                 --build=${_python_build_arch}-apple-darwin && \
             make -j${NPROC} python && \
             cd '<SOURCE_DIR>' && \
             env \
@@ -198,7 +191,6 @@ elseif(APPLE)
                 --without-static-libpython \
                 --with-openssl='${DESTDIR}' \
                 --disable-test-modules \
-                 ac_cv_func_pipe2=no ac_cv_func_dup3=no \
                 ${_python_build_tgt} \
                 --with-build-python='${_python_build_python}' \
                 py_cv_module__tkinter=n/a"
@@ -221,8 +213,6 @@ elseif(APPLE)
            --with-openssl=${DESTDIR}
            --disable-test-modules
            ${_python_build_tgt}
-            ac_cv_func_pipe2=no
-            ac_cv_func_dup3=no
            # Tcl/Tk 9.0 (e.g. from Homebrew) is incompatible with CPython 3.12's
            # _tkinter; OrcaSlicer's embedded Python does not need tkinter anyway.
            py_cv_module__tkinter=n/a
@@ -2582,8 +2582,12 @@ void GCodeProcessorResult::reset() {
    //BBS: add mutex for protection of gcode result
    lock();

-    moves.clear();
-    lines_ends.clear();
+    // release rather than clear: these two are sized by the print - one entry per move and one
+    // per g-code line - and a reset is where the memory is expected to go back to the allocator
+    // (see BackgroundSlicingProcess::apply()). The capacity would not be reused anyway: the
+    // result is refilled by move-assigning the processor's own result.
+    moves = std::vector<MoveVertex>();
+    lines_ends = std::vector<size_t>();
    printable_area = Pointfs();
    //BBS: add bed exclude area
    bed_exclude_area = Pointfs();
@@ -369,6 +369,56 @@ class Print;
            initial_layer_time = other.initial_layer_time;
 #if ENABLE_GCODE_VIEWER_STATISTICS
            time = other.time;
+#endif
+            return *this;
+        }
+        // Orca: the user-declared copy assignment above suppresses the implicit move assignment, so
+        // `*result = std::move(processor.extract_result())` used to deep copy 'moves' (one MoveVertex
+        // per move, gigabytes on a large print) while the source stayed alive. This moves exactly the
+        // same members as the copy above, with the same omissions, so the members the copy leaves
+        // untouched on the target are left untouched here too.
+        GCodeProcessorResult& operator=(GCodeProcessorResult &&other)
+        {
+            filename = std::move(other.filename);
+            id = other.id;
+            moves = std::move(other.moves);
+            lines_ends = std::move(other.lines_ends);
+            printable_area = std::move(other.printable_area);
+            bed_exclude_area = std::move(other.bed_exclude_area);
+            wrapping_exclude_area = std::move(other.wrapping_exclude_area);
+            toolpath_outside = other.toolpath_outside;
+            label_object_enabled = other.label_object_enabled;
+            long_retraction_when_cut = other.long_retraction_when_cut;
+            timelapse_warning_code = other.timelapse_warning_code;
+            printable_height = other.printable_height;
+            settings_ids = std::move(other.settings_ids);
+            filaments_count = other.filaments_count;
+            extruder_colors = std::move(other.extruder_colors);
+            filament_diameters = std::move(other.filament_diameters);
+            filament_densities = std::move(other.filament_densities);
+            filament_costs = std::move(other.filament_costs);
+            print_statistics = std::move(other.print_statistics);
+            custom_gcode_per_print_z = std::move(other.custom_gcode_per_print_z);
+            spiral_vase_mode = other.spiral_vase_mode;
+            warnings = std::move(other.warnings);
+            bed_type = other.bed_type;
+            gcode_check_result = std::move(other.gcode_check_result);
+            limit_filament_maps = std::move(other.limit_filament_maps);
+            filament_printable_reuslt = std::move(other.filament_printable_reuslt);
+            nozzle_group_result = std::move(other.nozzle_group_result);
+            extruder_types = std::move(other.extruder_types);
+            printer_extruder_variant = std::move(other.printer_extruder_variant);
+            printer_extruder_id = std::move(other.printer_extruder_id);
+            layer_filaments = std::move(other.layer_filaments);
+            filament_change_sequence = std::move(other.filament_change_sequence);
+            used_mixed_filaments = std::move(other.used_mixed_filaments);
+            nozzle_change_sequence = std::move(other.nozzle_change_sequence);
+            optimal_assignment = std::move(other.optimal_assignment);
+            filament_change_count_map = std::move(other.filament_change_count_map);
+            skippable_part_time = std::move(other.skippable_part_time);
+            initial_layer_time = other.initial_layer_time;
+#if ENABLE_GCODE_VIEWER_STATISTICS
+            time = other.time;
 #endif
            return *this;
        }
@@ -883,15 +883,17 @@ void ViewerImpl::reset()
    m_used_extruders.clear();
    m_total_time = { 0.0f, 0.0f };
    m_travels_time = { 0.0f, 0.0f };
-    m_vertices.clear();
-    m_vertices_colors.clear();
    // swap rather than clear: these are sized by the print, and a reset means the memory
    // should go back, not sit reserved until the next load
+    std::vector<PathVertex>().swap(m_vertices);
+    std::vector<float>().swap(m_vertices_colors);
    for (std::vector<float>& times : m_layer_start_times)
        std::vector<float>().swap(times);
    std::vector<uint32_t>().swap(m_layer_first_vertex);
    std::vector<float>().swap(m_colors_scratch);
-    m_valid_lines_bitset.clear();
+    // BitSet::clear() only zeroes the bits, it keeps the blocks allocated; load() builds a new
+    // bitset anyway and it is never read while m_vertices is empty
+    m_valid_lines_bitset = BitSet<>();
 #if VGCODE_ENABLE_COG_AND_TOOL_MARKERS
    m_cog_marker.reset();
 #endif // VGCODE_ENABLE_COG_AND_TOOL_MARKERS
@@ -1812,6 +1814,7 @@ size_t ViewerImpl::get_used_cpu_memory() const
    ret += sizeof(m_extrusion_roles_colors);
    ret += sizeof(m_options_colors);
    ret += STDVEC_MEMSIZE(m_vertices, PathVertex);
+    ret += STDVEC_MEMSIZE(m_vertices_colors, float);
    for (const std::vector<float>& times : m_layer_start_times)
        ret += STDVEC_MEMSIZE(times, float);
    ret += STDVEC_MEMSIZE(m_layer_first_vertex, uint32_t);
@@ -778,12 +778,8 @@ 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
@@ -924,7 +920,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 Crypt32)
+    target_link_libraries(libslic3r_gui Advapi32)
 endif()

 source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SLIC3R_GUI_SOURCES})
@@ -2,8 +2,8 @@
 #include "BBLNetworkPlugin.hpp"
 #include "IPrinterAgent.hpp"
 #include "NetworkAgentFactory.hpp"
-#include "libslic3r/Utils.hpp"
 #include "NetworkAgent.hpp"
+#include "libslic3r/Utils.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/DeviceCore/DevManager.h"

@@ -11,14 +11,13 @@
 #include <boost/log/trivial.hpp>
 #include <boost/nowide/fstream.hpp>
 #include <nlohmann/json.hpp>
+#include <cmath>
+#include <slic3r/GUI/DeviceManager.hpp>
 using json = nlohmann::json;

 #include <type_traits>
 #include <unordered_map>
 #include <memory>
-#include <nlohmann/json.hpp>
-#include <cmath>
-#include <slic3r/GUI/DeviceManager.hpp>

 namespace Slic3r {

@@ -198,9 +197,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;
@@ -210,9 +208,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;
@@ -233,11 +230,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;
 }

@@ -583,15 +579,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)
@@ -106,7 +106,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);
 };

@@ -282,11 +282,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";
@@ -1,7 +1,6 @@
 #ifndef __CREALITY_PRINT_AGENT_HPP__
 #define __CREALITY_PRINT_AGENT_HPP__

-#include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"

 #include <string>
@@ -14,19 +14,8 @@

 #include <curl/curl.h>

-#include <openssl/err.h>
-#include <openssl/ssl.h>
+#ifdef OPENSSL_CERT_OVERRIDE
 #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;
@@ -950,45 +939,6 @@ 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();
@@ -11,8 +11,6 @@
 #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,10 +198,6 @@ 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);
@@ -9,48 +9,11 @@
 #include <set>
 #include <string>
 #include <thread>
-#include <chrono>
-#include <condition_variable>
-#include <deque>
-#include <functional>

 #include <nlohmann/json.hpp>

 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:
@@ -96,20 +59,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;
@@ -121,9 +76,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
@@ -141,21 +94,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);
@@ -168,29 +112,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;
@@ -199,11 +127,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;

@@ -214,28 +141,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);
@@ -261,38 +182,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
@@ -302,14 +200,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
@@ -1,15 +1,11 @@
 #include "OrcaCloudServiceAgent.hpp"
 #include "Http.hpp"
-#include "ICameraSignalingChannel.hpp"
-#include "OrcaCloudSignalingChannel.hpp"
 #include "libslic3r/Utils.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 #include "libslic3r/AppConfig.hpp"

 #include <boost/asio.hpp>
 #include <boost/beast/core/detail/base64.hpp>
-#include <boost/beast/core.hpp>
-#include <boost/beast/websocket.hpp>
 #include <boost/filesystem.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/uuid/uuid.hpp>
@@ -25,18 +21,14 @@
 #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>
@@ -500,7 +492,6 @@ 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();
@@ -511,8 +502,6 @@ OrcaCloudServiceAgent::OrcaCloudServiceAgent(std::string log_dir)

 OrcaCloudServiceAgent::~OrcaCloudServiceAgent()
 {
-    if (mqtt_connection)
-        mqtt_connection->stop();
    if (refresh_thread.joinable()) {
        refresh_thread.join();
    }
@@ -830,9 +819,7 @@ int OrcaCloudServiceAgent::user_logout(bool request)
        }
    }

-    // An explicit logout also wipes the backend the token storage option is not using, so a token
-    // stranded by switching that option cannot sign the account back in later.
-    clear_session(/*all_backends=*/request);
+    clear_session();
    return BAMBU_NETWORK_SUCCESS;
 }

@@ -955,45 +942,22 @@ 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;
 }
@@ -1014,238 +978,13 @@ int OrcaCloudServiceAgent::stop_subscribe(std::string module)

 int OrcaCloudServiceAgent::add_subscribe(std::vector<std::string> dev_list)
 {
-    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;
+    (void) dev_list;
+    return BAMBU_NETWORK_SUCCESS;
 }

 int OrcaCloudServiceAgent::del_subscribe(std::vector<std::string> 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;
-    }
+    (void) dev_list;
    return BAMBU_NETWORK_SUCCESS;
 }

@@ -1865,9 +1604,7 @@ void OrcaCloudServiceAgent::persist_user_secret(const std::string& secret)
        }
    }

-    if (stored) {
-        secret_stored = true;
-    }
+    (void) stored;
 }

 bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
@@ -1907,7 +1644,6 @@ bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
                }

                if (integrity_ok && aes256gcm_decrypt(encoded_payload, key, plain) && !plain.empty()) {
-                    secret_stored = true;
                    out_secret = plain;
                    // Upgrade legacy payloads to signed format
                    if (payload.rfind("v2:", 0) != 0) {
@@ -1925,7 +1661,6 @@ bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
            if (store.Load(SECRET_STORE_SERVICE, username, secret) && secret.IsOk()) {
                out_secret.assign(static_cast<const char*>(secret.GetData()), secret.GetSize());
                if (!out_secret.empty()) {
-                    secret_stored = true;
                    return true;
                }
            }
@@ -1935,20 +1670,11 @@ bool OrcaCloudServiceAgent::load_user_secret(std::string& out_secret)
    return false;
 }

-void OrcaCloudServiceAgent::clear_user_secret(bool all_backends)
+void OrcaCloudServiceAgent::clear_user_secret()
 {
-    // Nothing this process loaded or saved: leave the store alone. Deleting would only cost a
-    // keychain round trip (or a hang while the keychain is unresponsive) and could remove a
-    // login another instance just saved.
-    if (!secret_stored.exchange(false) && !all_backends) {
-        return;
-    }
-
-    if (all_backends || !m_use_encrypted_token_file) {
-        wxSecretStore store = wxSecretStore::GetDefault();
-        if (store.IsOk()) {
-            store.Delete(SECRET_STORE_SERVICE);
-        }
+    wxSecretStore store = wxSecretStore::GetDefault();
+    if (store.IsOk()) {
+        store.Delete(SECRET_STORE_SERVICE);
    }

    compute_fallback_path();
@@ -2297,17 +2023,13 @@ bool OrcaCloudServiceAgent::set_user_session(const json& session_json, bool noti
    return success;
 }

-void OrcaCloudServiceAgent::clear_session(bool all_backends)
+void OrcaCloudServiceAgent::clear_session()
 {
-    if (mqtt_connection) {
-        mqtt_connection->stop();
-        mqtt_connection->clear_subscriptions();
-    }
    {
        std::lock_guard<std::mutex> lock(session_mutex);
        session = SessionInfo{};
    }
-    clear_user_secret(all_backends);
+    clear_user_secret();
 }

 // ============================================================================
@@ -2418,11 +2140,7 @@ 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,
-                                     const std::string& content_type)
+int OrcaCloudServiceAgent::http_post(const std::string& path, const std::string& body, std::string* response_body, unsigned int* http_code)
 {
    std::string url = api_base_url + path;
    BOOST_LOG_TRIVIAL(trace) << "OrcaCloudServiceAgent: POST " << url;
@@ -2446,7 +2164,7 @@ int OrcaCloudServiceAgent::http_post(const std::string& path,
                http.header("Authorization", "Bearer " + token);
            }

-            http.header("Content-Type", content_type);
+            http.header("Content-Type", "application/json");
            http.set_post_body(body);

            http.on_complete([&](std::string resp_body, unsigned resp_status) {
@@ -2913,28 +2631,19 @@ int OrcaCloudServiceAgent::get_user_print_info(unsigned int* http_code, std::str
    if (http_code)
        *http_code = code;

-    if (result != 0 || code != 200) {
-        BOOST_LOG_TRIVIAL(error) << "OrcaCloudServiceAgent: get_user_print_info failed - http_code=" << code << ", response=" << response;
+    if (result != 0 || code != 200)
        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())) {
-            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.
+            const std::string role = printer.value("access_role", "");
            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())
@@ -2948,20 +2657,15 @@ 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(device);
+            devices.push_back(std::move(device));
        }

        if (http_body) {
            nlohmann::json out;
-            out["devices"] = devices;
+            out["devices"] = std::move(devices);
            *http_body = out.dump();
        }
-
-        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();
+    } catch (const std::exception&) {
        return BAMBU_NETWORK_ERR_GET_SETTING_LIST_FAILED;
    }

@@ -3046,9 +2750,6 @@ 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)";
@@ -3,12 +3,6 @@

 #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 <cstdlib>
 #include <string>
 #include <map>
@@ -16,17 +10,12 @@
 #include <atomic>
 #include <chrono>
 #include <functional>
-#include <condition_variable>
-#include <cstdint>
-#include <set>
 #include <memory>
 #include <thread>
 #include <unordered_map>
 #include <vector>
 #include <nlohmann/json.hpp>

-#include "OrcaMqttConnection.hpp"
-
 class wxSecretStore;

 namespace Slic3r {
@@ -163,8 +152,6 @@ 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);
@@ -220,19 +207,6 @@ 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
@@ -268,7 +242,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 +326,7 @@ public:

    void persist_user_secret(const std::string& secret);
    bool load_user_secret(std::string& out_secret);
-    void clear_user_secret(bool all_backends = false);
+    void clear_user_secret();

    // Token refresh helpers
    bool          refresh_if_expiring(std::chrono::seconds skew, const std::string& reason);
@@ -370,33 +344,11 @@ public:
                          bool persist = true);
    // Accepts either nested Orca cloud / GoTrue session JSON or flat WebView token JSON.
    bool set_user_session(const nlohmann::json& session_json, bool notify_login = true);
-    void clear_session(bool all_backends = false);
+    void clear_session();

    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,
@@ -420,11 +372,7 @@ 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,
-                  const std::string& content_type = "application/json");
+    int http_post(const std::string& path, const std::string& body, std::string* response_body, unsigned int* http_code);
    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();
@@ -465,11 +413,6 @@ private:
    // Member variables - auth state
    PkceBundle pkce_bundle;
    std::string secret_fallback_path;
-    // Set once this process has read a secret from the store or written one. Unless the user logs
-    // out explicitly, clear_user_secret() only touches the store while it is set, so a logged-out
-    // instance (the GUI polls the login status every 2 s) makes no keychain calls and cannot wipe
-    // a login another instance saved.
-    std::atomic_bool secret_stored{false};
    SessionHandler session_handler;
    OnLoginCompleteHandler on_login_complete_handler;
    SessionInfo session;
@@ -482,9 +425,6 @@ 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};
@@ -498,7 +438,6 @@ 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
@@ -1,337 +0,0 @@
-#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
@@ -1,66 +0,0 @@
-#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
@@ -1,805 +0,0 @@
-#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
@@ -1,155 +0,0 @@
-#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_
@@ -3,28 +3,19 @@

 #include "IPrinterAgent.hpp"
 #include "ICloudServiceAgent.hpp"
-#include "OrcaCloudServiceAgent.hpp"
-#include "OrcaMqttConnection.hpp"
-#include <atomic>
-#include <cstdint>
-#include <functional>
 #include <string>
 #include <mutex>
 #include <memory>
-#include <thread>

 namespace Slic3r {

-class OrcaCloudServiceAgent;
-
 /**
- * OrcaPrinterAgent - OrcaSonar MQTT printer agent.
+ * OrcaPrinterAgent - Stub implementation for printer operations.
 *
- * LAN and cloud commands use the same OrcaSonar protocol payloads; only the
- * MQTT connection selected by route_send() differs.
+ * All printer-related operations are currently stubs that return success.
+ * Actual printer connectivity requires the BBL SDK or future Orca implementation.
 */
-class OrcaPrinterAgent : public IPrinterAgent
-{
+class OrcaPrinterAgent : public IPrinterAgent {
 public:
    explicit OrcaPrinterAgent(std::string log_dir);
    ~OrcaPrinterAgent() override;
@@ -34,8 +25,6 @@ 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;

    // Communication
    int send_message(std::string dev_id, std::string json_str, int qos, int flag) override;
@@ -79,131 +68,10 @@ 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);
-
-    // 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);
-    // 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;
@@ -1,6 +1,5 @@
 #include "QidiPrinterAgent.hpp"
 #include "Http.hpp"
-#include "IPrinterAgent.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"

@@ -9,7 +8,6 @@
 #include <boost/log/trivial.hpp>
 #include <cctype>
 #include <sstream>
-#include <thread>

 using json = nlohmann::json;

@@ -29,15 +27,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";
@@ -51,148 +40,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";
    }
@@ -202,9 +94,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)
@@ -229,10 +120,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) {
@@ -307,45 +208,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)
@@ -1,9 +1,7 @@
 #ifndef __QIDI_PRINTER_AGENT_HPP__
 #define __QIDI_PRINTER_AGENT_HPP__

-#include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
-#include "nlohmann/json_fwd.hpp"

 #include <map>
 #include <string>
@@ -23,23 +21,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 +29,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);
@@ -1,14 +1,10 @@
 #include "SnapmakerPrinterAgent.hpp"
 #include "Http.hpp"
-#include "IPrinterAgent.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"

 #include "nlohmann/json.hpp"
 #include <boost/log/trivial.hpp>
-#include <chrono>
-#include <sstream>
-#include <thread>

 using json = nlohmann::json;

@@ -17,13 +13,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>
@@ -80,31 +69,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"};
@@ -140,149 +104,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
@@ -1,10 +1,7 @@
 #pragma once

-#include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"

-#include <atomic>
-#include <cstdint>
 #include <string>

 namespace Slic3r {
@@ -19,19 +16,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
@@ -13,7 +13,6 @@ add_executable(${_TEST_NAME}_tests
    test_prebuild_queue.cpp
    test_staged_build.cpp
    test_network_versions.cpp
-    test_orca_cloud_agent.cpp
    test_action_source.cpp
    test_plugin_host_api.cpp
    # Exercise seam enums and predicates through the embedded Python host API.
@@ -23,9 +22,6 @@ add_executable(${_TEST_NAME}_tests
    test_plugin_capabilities_in_use.cpp
    test_plugin_status.cpp
    test_printer_agent.cpp
-    test_qidi_printer_agent.cpp
-    test_orca_mqtt_connection.cpp
-    test_orca_printer_agent.cpp
    test_plugin_install.cpp
    test_plugin_lifecycle.cpp
    test_plugin_printer_agent.cpp
@@ -1,325 +0,0 @@
-#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
@@ -6,7 +6,6 @@
 #include <boost/filesystem.hpp>
 #include <memory.h>
 #include <stdexcept>
-#include <string>
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>

@@ -26,15 +25,8 @@ void ensure_python_initialized()
    config.parse_argv = 0;

    const auto python_home = boost::dll::program_location().parent_path() / "python";
-#ifdef _WIN32
-    const auto stdlib = python_home / "Lib";
-#else
-    const auto stdlib = python_home / "lib" /
-                        ("python" + std::to_string(PY_MAJOR_VERSION) + "." + std::to_string(PY_MINOR_VERSION));
-#endif

-    // Only a real runtime: a stray python/ folder (packages a test left behind) is not a home.
-    if (boost::filesystem::exists(stdlib / "encodings")) {
+    if (boost::filesystem::exists(python_home)) {
        const std::string home = python_home.string();
        const PyStatus status  = PyConfig_SetBytesString(&config, &config.home, home.c_str());

@@ -1,86 +0,0 @@
-#include <catch2/catch_all.hpp>
-
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
-
-#include <memory>
-#include <string>
-
-#include "slic3r/Utils/OrcaCloudServiceAgent.hpp"
-#include "test_utils.hpp"
-
-using namespace Slic3r;
-namespace fs = boost::filesystem;
-
-namespace {
-
-// The encrypted token file is the one secret backend a test can observe without a system
-// keychain. Every agent pointed at the same directory shares it, like separate app instances
-// share the keychain entry.
-std::unique_ptr<OrcaCloudServiceAgent> make_file_backed_agent(const fs::path& dir)
-{
-    auto agent = std::make_unique<OrcaCloudServiceAgent>(dir.string());
-    agent->set_use_encrypted_token_file(true);
-    agent->set_config_dir(dir.string());
-    return agent;
-}
-
-fs::path secret_file(const fs::path& dir) { return dir / secret_constants::USER_SECRET_FILENAME; }
-
-} // namespace
-
-TEST_CASE("Logging out removes the secret this instance saved", "[OrcaCloudServiceAgent]")
-{
-    ScopedTemporaryDir dir("orca-secret");
-    auto agent = make_file_backed_agent(dir.path());
-
-    agent->persist_user_secret("refresh-token");
-    REQUIRE(fs::exists(secret_file(dir.path())));
-
-    agent->user_logout(false);
-    CHECK_FALSE(fs::exists(secret_file(dir.path())));
-}
-
-TEST_CASE("Logging out removes a secret this instance loaded from the store", "[OrcaCloudServiceAgent]")
-{
-    ScopedTemporaryDir dir("orca-secret");
-    make_file_backed_agent(dir.path())->persist_user_secret("refresh-token");
-
-    auto        agent = make_file_backed_agent(dir.path());
-    std::string secret;
-    REQUIRE(agent->load_user_secret(secret));
-    CHECK(secret == "refresh-token");
-
-    agent->user_logout(false);
-    CHECK_FALSE(fs::exists(secret_file(dir.path())));
-}
-
-TEST_CASE("Logging out leaves a secret this instance never loaded or saved alone", "[OrcaCloudServiceAgent]")
-{
-    ScopedTemporaryDir dir("orca-secret");
-    make_file_backed_agent(dir.path())->persist_user_secret("refresh-token");
-
-    // A logged-out instance is asked to log out on every login-status poll.
-    auto other = make_file_backed_agent(dir.path());
-    other->user_logout(false);
-    other->user_logout(false);
-    CHECK(fs::exists(secret_file(dir.path())));
-
-    std::string secret;
-    REQUIRE(make_file_backed_agent(dir.path())->load_user_secret(secret));
-    CHECK(secret == "refresh-token");
-}
-
-TEST_CASE("Logging out leaves a secret this instance could not read alone", "[OrcaCloudServiceAgent]")
-{
-    ScopedTemporaryDir dir("orca-secret");
-    // Written under another encryption key, e.g. by another OS user sharing the data directory.
-    fs::ofstream(secret_file(dir.path())) << "v2:0000:not-a-payload-this-user-can-decrypt";
-
-    auto        agent = make_file_backed_agent(dir.path());
-    std::string secret;
-    REQUIRE_FALSE(agent->load_user_secret(secret));
-
-    agent->user_logout(false);
-    CHECK(fs::exists(secret_file(dir.path())));
-}
@@ -1,243 +0,0 @@
-#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();
-}
@@ -1,208 +0,0 @@
-#include <catch2/catch_test_macros.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;
-};
-}
-
-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::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("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();
-}
@@ -38,9 +38,6 @@ namespace {
 // before this destructor's shutdown() runs.
 struct ScopedPluginManager
 {
-    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
-    // which would otherwise land in the working directory.
-    ScopedDataDir python_data_dir{"plugin-python"};
    bool initialized = PluginManager::instance().initialize();

    ~ScopedPluginManager()
@@ -31,9 +31,6 @@ namespace {
 // same as any other plugin.
 struct ScopedManagerShutdown
 {
-    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
-    // which would otherwise land in the working directory.
-    ScopedDataDir python_data_dir{"plugin-python"};
    bool initialized = PluginManager::instance().initialize();

    ~ScopedManagerShutdown()
@@ -42,9 +42,6 @@ namespace {
 // Declare this FIRST in a test so it is destroyed last.
 struct ScopedPluginManager
 {
-    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
-    // which would otherwise land in the working directory.
-    ScopedDataDir python_data_dir{"plugin-python"};
    bool initialized = false;

    ScopedPluginManager() { initialized = PluginManager::instance().initialize(); }
@@ -12,8 +12,6 @@
 #include <memory>
 #include <string>

-#include "plugin_test_utils.hpp"
-
 namespace py = pybind11;
 using namespace Slic3r;

@@ -23,9 +21,6 @@ namespace {
 // into Python unless PythonInterpreter::instance() reports initialized.
 struct ScopedPluginManager
 {
-    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
-    // which would otherwise land in the working directory.
-    ScopedDataDir python_data_dir{"plugin-python"};
    bool initialized = PluginManager::instance().initialize();

    ~ScopedPluginManager()
@@ -1,7 +1,5 @@
 #include <catch2/catch_all.hpp>

-#include <slic3r/Utils/BBLPrinterAgent.hpp>
-#include <slic3r/Utils/MoonrakerPrinterAgent.hpp>
 #include <slic3r/Utils/NetworkAgentFactory.hpp>
 #include <slic3r/plugin/PythonPluginBridge.hpp>

@@ -10,156 +8,11 @@
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>

-#include <atomic>
-#include <chrono>
-#include <future>
-#include <memory>
 #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
@@ -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");
-}
@@ -35,9 +35,6 @@ namespace {

 struct ScopedPluginManager
 {
-    // Before initialize(): the interpreter creates {data_dir}/python/packages and {data_dir}/log,
-    // which would otherwise land in the working directory.
-    ScopedDataDir python_data_dir{"plugin-python"};
    bool initialized = false;

    ScopedPluginManager() { initialized = PluginManager::instance().initialize(); }