Initial Commit for OrcaPrinterAgent AMS Sync

This reverts commit 910dbcd2e6.

.github/workflows/build_orca.yml

@@ -85,15 +85,6 @@ jobs:
         shell: bash
         run: |
           leg="${{ runner.os }}-${{ inputs.arch || 'amd64' }}${{ runner.os == 'Windows' && format('-{0}', inputs.compiler) || '' }}"
-          # clang-cl refuses a precompiled header from another cl.exe build and ccache
-          # does not hash that build, so each one gets its own cache. The build number
-          # is read from cl.exe itself; the toolset directory keeps its name across patches.
-          if [ "${{ runner.os }}" = Windows ]; then
-            vswhere='/c/Program Files (x86)/Microsoft Visual Studio/Installer/vswhere.exe'
-            toolset=$(tr -d '\r\n' < "$("$vswhere" -latest -products '*' -find 'VC\Auxiliary\Build\Microsoft.VCToolsVersion.default.txt' | tr -d '\r')")
-            cl=$("$vswhere" -latest -products '*' -find 'VC\Tools\MSVC\'"$toolset"'\**\cl.exe' | tr -d '\r' | head -1)
-            leg="$leg-vc$("$cl" 2>&1 | grep -o -E 'Version [0-9.]+' | cut -d' ' -f2)"
-          fi
           echo "CCACHE_LEG=$leg" >> "$GITHUB_ENV"
           echo "CCACHE_ENTRY=ccache-$leg-${{ github.run_id }}-${{ github.run_attempt }}" >> "$GITHUB_ENV"
 

CMakeLists.txt

@@ -821,6 +821,37 @@ find_package(OpenSSL REQUIRED)
 find_package(CURL REQUIRED)
 find_package(Freetype REQUIRED)
 
+if (SLIC3R_GUI)
+    # LibDataChannel's installed export references its bundled dependencies,
+    # but does not install their CMake targets. Recreate those targets from
+    # the same dependency prefix before loading the LibDataChannel config.
+    if (NOT TARGET Usrsctp::usrsctp)
+        find_library(_ORCA_USRSCTP_LIBRARY NAMES usrsctp
+            PATHS "${CMAKE_PREFIX_PATH}/lib" NO_DEFAULT_PATH)
+        if (_ORCA_USRSCTP_LIBRARY)
+            add_library(Usrsctp::usrsctp UNKNOWN IMPORTED GLOBAL)
+            set_target_properties(Usrsctp::usrsctp PROPERTIES
+                IMPORTED_LOCATION "${_ORCA_USRSCTP_LIBRARY}"
+                IMPORTED_LINK_INTERFACE_LANGUAGES C
+                INTERFACE_LINK_LIBRARIES "Threads::Threads")
+        endif()
+    endif()
+
+    if (NOT TARGET LibJuice::LibJuice)
+        find_library(_ORCA_LIBJUICE_LIBRARY NAMES juice
+            PATHS "${CMAKE_PREFIX_PATH}/lib" NO_DEFAULT_PATH)
+        if (_ORCA_LIBJUICE_LIBRARY)
+            add_library(LibJuice::LibJuice UNKNOWN IMPORTED GLOBAL)
+            set_target_properties(LibJuice::LibJuice PROPERTIES
+                IMPORTED_LOCATION "${_ORCA_LIBJUICE_LIBRARY}"
+                IMPORTED_LINK_INTERFACE_LANGUAGES C
+                INTERFACE_LINK_LIBRARIES "Threads::Threads")
+        endif()
+    endif()
+
+    find_package(LibDataChannel CONFIG REQUIRED)
+endif()
+
 
 add_library(libcurl INTERFACE)
 target_link_libraries(libcurl INTERFACE CURL::libcurl)
@@ -1103,6 +1134,7 @@ function(orcaslicer_copy_dlls target config postfix output_dlls)
             ${CMAKE_PREFIX_PATH}/bin/occt/TKXDESTEP.dll
             ${CMAKE_PREFIX_PATH}/bin/occt/TKXSBase.dll
             ${CMAKE_PREFIX_PATH}/bin/freetype.dll
+            ${CMAKE_PREFIX_PATH}/bin/avformat-61.dll
             ${CMAKE_PREFIX_PATH}/bin/avcodec-61.dll
             ${CMAKE_PREFIX_PATH}/bin/swresample-5.dll
             ${CMAKE_PREFIX_PATH}/bin/swscale-8.dll
@@ -1142,6 +1174,7 @@ function(orcaslicer_copy_dlls target config postfix output_dlls)
         ${_out_dir}/TKXSBase.dll
 
         ${_out_dir}/freetype.dll
+        ${_out_dir}/avformat-61.dll
         ${_out_dir}/avcodec-61.dll
         ${_out_dir}/swresample-5.dll
         ${_out_dir}/swscale-8.dll
@@ -1164,7 +1197,10 @@ function(orcaslicer_copy_sos target config postfix output_sos)
         set(_out_dir "${CMAKE_CURRENT_BINARY_DIR}")
     endif ()
 
-    file(COPY ${CMAKE_PREFIX_PATH}/lib/libavcodec.so
+    file(COPY ${CMAKE_PREFIX_PATH}/lib/libavformat.so
+            ${CMAKE_PREFIX_PATH}/lib/libavformat.so.61
+            ${CMAKE_PREFIX_PATH}/lib/libavformat.so.61.1.100
+            ${CMAKE_PREFIX_PATH}/lib/libavcodec.so
             ${CMAKE_PREFIX_PATH}/lib/libavcodec.so.61
             ${CMAKE_PREFIX_PATH}/lib/libavcodec.so.61.3.100
             ${CMAKE_PREFIX_PATH}/lib/libavutil.so
@@ -1179,6 +1215,9 @@ function(orcaslicer_copy_sos target config postfix output_sos)
          DESTINATION ${_out_dir})
 
     set(${output_sos}
+        ${_out_dir}/libavformat.so
+        ${_out_dir}/libavformat.so.61
+        ${_out_dir}/libavformat.so.61.1.100
         ${_out_dir}/libavcodec.so
         ${_out_dir}/libavcodec.so.61
         ${_out_dir}/libavcodec.so.61.3.100
@@ -1308,6 +1347,8 @@ endif ()
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
     set(LIBRARY_FILES
+    ${LIBDIR_BIN}/libavformat.so.61
+    ${LIBDIR_BIN}/libavformat.so.61.1.100
     ${LIBDIR_BIN}/libavcodec.so.61
     ${LIBDIR_BIN}/libavcodec.so.61.3.100
     ${LIBDIR_BIN}/libavutil.so.59

build_linux.sh

@@ -8,7 +8,7 @@ SCRIPT_PATH=$(dirname "$(readlink -f "${0}")")
 pushd "${SCRIPT_PATH}" > /dev/null
 
 function usage() {
-    echo "Usage: ./${SCRIPT_NAME} [-1][-b][-c][-d][-D][-e][-F][-g][-h][-i][-j N][-p][-r][-s][-t][-u][-l][-L [lld|mold]]"
+    echo "Usage: ./${SCRIPT_NAME} [-1][-b][-c][-d][-D][-e][-F][-g][-h][-i][-j N][-p][-r][-s][-t][-u][-l][-L]"
     echo "   -1: limit builds to one core (where possible)"
     echo "   -j N: limit builds to N cores (where possible)"
     echo "   -b: build in Debug mode"
@@ -27,7 +27,7 @@ function usage() {
     echo "   -t: build tests (optional), requires -s flag"
     echo "   -u: install system dependencies (asks for sudo password; build prerequisite)"
     echo "   -l: use Clang instead of GCC (default: GCC)"
-    echo "   -L [lld|mold]: use an alternate linker (if available) (default: lld)"
+    echo "   -L: use ld.lld as linker (if available)"
     echo "For a first use, you want to './${SCRIPT_NAME} -u'"
     echo "   and then './${SCRIPT_NAME} -dsi'"
     echo "For a GitHub Actions-like Linux build locally, use './${SCRIPT_NAME} -g -istrlL'"
@@ -115,24 +115,8 @@ while getopts ":1j:bcCdDeFghiprstulL" opt ; do
         FORWARDED_ARGS+=("-l")
         ;;
     L )
-        # -L takes an optional argument. getopts has no native support for
-        # this, so L is declared bare (no ':') in the optstring above, and we
-        # manually peek at the next unconsumed argv token via ${!OPTIND}. If
-        # it's a bare 'lld' or 'mold' (not another option, i.e. doesn't start
-        # with '-'), consume it as the explicit choice and advance OPTIND so
-        # getopts doesn't reprocess it as a new flag. Otherwise, leave it
-        # alone (it isn't meant for -L) and default to lld.
-        LINKER_NAME="lld"
-        next_arg="${!OPTIND-}"
-        if [[ -n "${next_arg}" ]] && [[ "${next_arg}" != -* ]] ; then
-            case "${next_arg}" in
-                lld|mold )
-                    LINKER_NAME="${next_arg}"
-                    OPTIND=$((OPTIND + 1))
-                    ;;
-            esac
-        fi
-        FORWARDED_ARGS+=("-L" "${LINKER_NAME}")
+        USE_LLD="1"
+        FORWARDED_ARGS+=("-L")
         ;;
     * )
 	echo "Unknown argument '${opt}', aborting."
@@ -146,23 +130,11 @@ if [ ${OPTIND} -eq 1 ] ; then
     exit 1
 fi
 
-shift $((OPTIND - 1))
-if [ $# -ne 0 ] ; then
-    echo "Unknown argument '$1', aborting."
-    exit 1
-fi
-
 if [[ -n "${CLEAN_DOCKER_IMAGE}" ]] && [[ -z "${USE_DOCKER}" ]] ; then
     echo "Error: -F requires -g."
     exit 1
 fi
 
-if [[ -n "${USE_DOCKER}" ]] && [[ "${LINKER_NAME}" == "mold" ]] ; then
-    echo "Error: -L mold is not available in the Docker/Podman build image, so -g and -L mold cannot be combined."
-    echo "Omit -L mold when using -g (the container build defaults to GCC without mold), or drop -g and build with -L mold directly on a host with mold installed."
-    exit 1
-fi
-
 function check_available_memory_and_disk() {
     FREE_MEM_GB=$(free --gibi --total | grep 'Mem' | rev | cut --delimiter=" " --fields=1 | rev)
     MIN_MEM_GB=10
@@ -520,49 +492,14 @@ if [[ -n "${USE_CLANG}" ]] ; then
     export CMAKE_C_CXX_COMPILER_CLANG=(-DCMAKE_C_COMPILER=/usr/bin/clang -DCMAKE_CXX_COMPILER=/usr/bin/clang++)
 fi
 
-# Configure use of an alternate linker (-L lld or -L mold) when requested
-export CMAKE_LINKER_ARGS=()
-if [[ -n "${LINKER_NAME}" ]] ; then
-    case "${LINKER_NAME}" in
-        lld )
-            LINKER_BIN_NAME="ld.lld"
-            ;;
-        mold )
-            LINKER_BIN_NAME="mold"
-            # -fuse-ld=mold requires GCC 12.1+. Older GCC (e.g. GCC 11, shipped
-            # for Ubuntu 22.x via scripts/linux.d/debian) doesn't understand the
-            # flag, and cmake's compiler check then fails with a confusing
-            # generic "is not able to compile a simple test program" error
-            # instead of naming the real cause. Catch it here instead.
-            if [[ -z "${USE_CLANG}" ]] ; then
-                GCC_BIN="${CC:-gcc}"
-                if ! command -v "${GCC_BIN}" >/dev/null 2>&1 ; then
-                    GCC_BIN="cc"
-                fi
-                if command -v "${GCC_BIN}" >/dev/null 2>&1 ; then
-                    GCC_VERSION=$("${GCC_BIN}" -dumpfullversion 2>/dev/null)
-                    if [[ -n "${GCC_VERSION}" ]] && [[ "$(printf '%s\n%s\n' "${GCC_VERSION}" "12.1" | sort -V | head -n1)" != "12.1" ]] ; then
-                        echo "Error: -L mold requires GCC 12.1 or newer to support -fuse-ld=mold (found GCC ${GCC_VERSION} via '${GCC_BIN}')."
-                        echo "Use -l to build with Clang instead, upgrade your GCC toolchain, or omit -L mold."
-                        exit 1
-                    fi
-                fi
-            fi
-            ;;
-    esac
-
-    if command -v "${LINKER_BIN_NAME}" >/dev/null 2>&1 ; then
-        LINKER_BIN=$(command -v "${LINKER_BIN_NAME}")
-        export CMAKE_LINKER_ARGS=(-DCMAKE_LINKER="${LINKER_BIN}" "-DCMAKE_EXE_LINKER_FLAGS=-fuse-ld=${LINKER_NAME}" "-DCMAKE_SHARED_LINKER_FLAGS=-fuse-ld=${LINKER_NAME}" "-DCMAKE_MODULE_LINKER_FLAGS=-fuse-ld=${LINKER_NAME}")
+# Configure use of ld.lld as the linker when requested
+export CMAKE_LLD_LINKER_ARGS=()
+if [[ -n "${USE_LLD}" ]] ; then
+    if command -v ld.lld >/dev/null 2>&1 ; then
+        LLD_BIN=$(command -v ld.lld)
+        export CMAKE_LLD_LINKER_ARGS=(-DCMAKE_LINKER="${LLD_BIN}" -DCMAKE_EXE_LINKER_FLAGS=-fuse-ld=lld -DCMAKE_SHARED_LINKER_FLAGS=-fuse-ld=lld -DCMAKE_MODULE_LINKER_FLAGS=-fuse-ld=lld)
     else
-        case "${LINKER_NAME}" in
-            lld )
-                echo "Error: ld.lld not found. Please install the 'lld' package (e.g., sudo apt install lld) or omit -L lld."
-                ;;
-            mold )
-                echo "Error: mold not found. Please install the 'mold' package or omit -L mold."
-                ;;
-        esac
+        echo "Error: ld.lld not found. Please install the 'lld' package (e.g., sudo apt install lld) or omit -L."
         exit 1
     fi
 fi
@@ -599,7 +536,7 @@ if [[ -n "${BUILD_DEPS}" ]] ; then
         BUILD_ARGS+=(-DCMAKE_BUILD_TYPE="${BUILD_CONFIG}")
     fi
 
-    print_and_run cmake -S deps -B deps/$BUILD_DIR "${CMAKE_C_CXX_COMPILER_CLANG[@]}" "${CMAKE_LINKER_ARGS[@]}" "${CMAKE_CCACHE_ARGS[@]}" -G Ninja "${COLORED_OUTPUT}" "${BUILD_ARGS[@]}"
+    print_and_run cmake -S deps -B deps/$BUILD_DIR "${CMAKE_C_CXX_COMPILER_CLANG[@]}" "${CMAKE_LLD_LINKER_ARGS[@]}" "${CMAKE_CCACHE_ARGS[@]}" -G Ninja "${COLORED_OUTPUT}" "${BUILD_ARGS[@]}"
     print_and_run cmake --build deps/$BUILD_DIR -j1
 fi
 
@@ -619,7 +556,7 @@ if [[ -n "${BUILD_ORCA}" ]] || [[ -n "${BUILD_TESTS}" ]] ; then
         BUILD_ARGS+=(-DORCA_UPDATER_SIG_KEY="${ORCA_UPDATER_SIG_KEY}")
     fi
 
-    print_and_run cmake -S . -B $BUILD_DIR "${CMAKE_C_CXX_COMPILER_CLANG[@]}" "${CMAKE_LINKER_ARGS[@]}" "${CMAKE_CCACHE_ARGS[@]}" -G "Ninja Multi-Config" \
+    print_and_run cmake -S . -B $BUILD_DIR "${CMAKE_C_CXX_COMPILER_CLANG[@]}" "${CMAKE_LLD_LINKER_ARGS[@]}" "${CMAKE_CCACHE_ARGS[@]}" -G "Ninja Multi-Config" \
 -DSLIC3R_PCH=${SLIC3R_PRECOMPILED_HEADERS} \
 -DORCA_TOOLS=ON \
 "${COLORED_OUTPUT}" \

deps/Boost/Boost.cmake

@@ -27,15 +27,8 @@ endif ()
 # Boost.Container's bundled dlmalloc passes int* where the Win32 Interlocked API
 # takes volatile long*; cl compiles that with a warning, clang errors out.
 set(_boost_c_flags_line "")
-set(_boost_cxx_flags_line "")
 if (MSVC AND CMAKE_C_COMPILER_ID STREQUAL "Clang")
     set(_boost_c_flags_line "-DCMAKE_C_FLAGS:STRING=-Wno-incompatible-pointer-types")
-    # The Visual Studio generator applies only the link language's flags to a
-    # project, and boost_container links as C++, so its C file never sees
-    # CMAKE_C_FLAGS. The C++ flags reach every file; keep CMake's defaults.
-    if (CMAKE_GENERATOR MATCHES "Visual Studio")
-        set(_boost_cxx_flags_line "-DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} -Wno-incompatible-pointer-types")
-    endif ()
 endif ()
 
 orcaslicer_add_cmake_project(Boost
@@ -53,7 +46,6 @@ orcaslicer_add_cmake_project(Boost
         "${_context_arch_line}"
         "${_context_impl_line}"
         "${_boost_c_flags_line}"
-        "${_boost_cxx_flags_line}"
 )
 
 set(DEP_Boost_DEPENDS ZLIB)

deps/CMakeLists.txt

@@ -184,11 +184,6 @@ function(orcaslicer_add_cmake_project projectname)
 
     if (_dep_msvc_gen)
       set(_gen CMAKE_GENERATOR "${DEP_MSVC_GEN}" CMAKE_GENERATOR_PLATFORM "${DEP_PLATFORM}")
-      # The toolset picks the compiler here, not the CMAKE_<LANG>_COMPILER
-      # forwarded below, so without it a clang-cl superbuild builds with cl.
-      if (CMAKE_GENERATOR_TOOLSET)
-        list(APPEND _gen CMAKE_GENERATOR_TOOLSET "${CMAKE_GENERATOR_TOOLSET}")
-      endif ()
     else()
       set(_gen "")
     endif()
@@ -380,10 +375,6 @@ include(libnoise/libnoise.cmake)
 
 include(Draco/Draco.cmake)
 
-include(FFMPEG/FFMPEG.cmake)
-include(Assimp/Assimp.cmake)
-
-
 # I *think* 1.1 is used for *just* md5 hashing?
 # 3.1 has everything in the right place, but the md5 funcs used are deprecated
 # a grep across the repo shows it is used for other things
@@ -394,6 +385,12 @@ if(NOT OPENSSL_FOUND)
     set(OPENSSL_PKG dep_OpenSSL)
 endif()
 
+include(FFMPEG/FFMPEG.cmake)
+include(Assimp/Assimp.cmake)
+
+include(DataChannel/DataChannel.cmake)
+set(DATACHANNEL_PKG dep_DataChannel)
+
 # we don't want to load a "wrong" openssl when loading curl
 # so, just don't even bother
 # ...i think this is how it works? change if wrong
@@ -466,6 +463,7 @@ set(_dep_list
     dep_wxInspector
     dep_FFMPEG
     dep_Assimp
+    ${DATACHANNEL_PKG}
     )
 
 if (MSVC)

deps/DataChannel/DataChannel.cmake

@@ -0,0 +1,20 @@
+# libdatachannel is the native ICE/DTLS/SCTP implementation used by the
+# GUI WebRTC camera controller. Keep the source revision fixed: the signaling
+# protocol is evolving independently of this transport dependency.
+orcaslicer_add_cmake_project(DataChannel
+    DEPENDS ${OPENSSL_PKG}
+    CMAKE_ARGS
+        -DNO_EXAMPLES=ON
+        -DNO_TESTS=ON
+        -DNO_WEBSOCKET=ON
+        -DNO_MEDIA=ON
+        -DUSE_NICE=OFF
+        -DUSE_SYSTEM_JUICE=OFF
+        -DUSE_SYSTEM_USRSCTP=OFF
+        -DOPENSSL_ROOT_DIR:PATH=${DESTDIR}
+        -DOPENSSL_USE_STATIC_LIBS=ON
+    GIT_REPOSITORY https://github.com/paullouisageneau/libdatachannel.git
+    GIT_TAG v0.22.2
+    GIT_SHALLOW ON
+    GIT_SUBMODULES_RECURSE ON
+)

deps/Draco/Draco.cmake

@@ -7,7 +7,4 @@ orcaslicer_add_cmake_project(Draco
     ${_options}
     URL https://github.com/google/draco/archive/refs/tags/1.5.7.zip
     URL_HASH SHA256=27b72ba2d5ff3d0a9814ad40d4cb88f8dc89a35491c0866d952473f8f9416b77
-    CMAKE_ARGS
-        # The encoder and decoder tools duplicate draco.lib; see deps-windows.cmake.
-        "${DEP_LLD_FORCE_MULTIPLE}"
 )

deps/FFMPEG/FFMPEG.cmake

@@ -1,5 +1,16 @@
 set(_conf_cmd ./configure)
 
+set(_ffmpeg_depends)
+set(_ffmpeg_configure_command ${_conf_cmd})
+if (TARGET dep_OpenSSL)
+    set(_ffmpeg_depends DEPENDS dep_OpenSSL)
+    set(_ffmpeg_configure_command
+        ${CMAKE_COMMAND} -E env
+        "PKG_CONFIG_PATH=${DESTDIR}/lib/pkgconfig:$ENV{PKG_CONFIG_PATH}"
+        ${_conf_cmd}
+    )
+endif()
+
 if (MSVC)
     set(_source_dir "${CMAKE_BINARY_DIR}/dep_FFMPEG-prefix/src/dep_FFMPEG")
 
@@ -9,6 +20,7 @@ if (MSVC)
     set(PREBUILD_HASH_x64 "e65916020ddb9ef84b2666dfbcbfc9b1d67f69d15b4a66db53754637bf2d498c")
 
     ExternalProject_Add(dep_FFMPEG
+        ${_ffmpeg_depends}
         URL ${PREBUILD_URL_${DEPS_ARCH}}
         URL_HASH SHA256=${PREBUILD_HASH_${DEPS_ARCH}}
         DOWNLOAD_DIR ${DEP_DOWNLOAD_DIR}/FFMPEG
@@ -21,6 +33,8 @@ if (MSVC)
     )
 
 else ()
+    set(_openssl_cmd --enable-openssl)
+
     if (APPLE)
         set(_minos_cmd
             "--extra-cflags=-mmacosx-version-min=${DEP_OSX_TARGET}"
@@ -52,10 +66,11 @@ else ()
     endif()
 
     ExternalProject_Add(dep_FFMPEG
+        ${_ffmpeg_depends}
         URL https://github.com/FFmpeg/FFmpeg/archive/refs/tags/n7.0.3.tar.gz
         URL_HASH SHA256=DEEDCABE339165214A3637DF4C86A507AEF0D793CF8774FF68735F4737E8DDBC
         DOWNLOAD_DIR ${DEP_DOWNLOAD_DIR}/FFMPEG
-        CONFIGURE_COMMAND ${_conf_cmd}
+        CONFIGURE_COMMAND ${_ffmpeg_configure_command}
             ${_cross_cmd}
             ${_pic_cmd}
             ${_arch_cmd}
@@ -63,20 +78,21 @@ else ()
             "--prefix=${DESTDIR}"
             ${_link_cmd}
             ${_minos_cmd}
+            ${_openssl_cmd}
             --disable-doc
             --enable-small
             --disable-outdevs
             --disable-filters
             --enable-filter=*null*,afade,*fifo,*format,*resample,aeval,allrgb,allyuv,atempo,pan,*bars,color,*key,crop,draw*,eq*,framerate,*_qsv,*_vaapi,*v4l2*,hw*,scale,volume,test*
             --disable-protocols
-            --enable-protocol=file,fd,pipe,rtp,udp
+            --enable-protocol=file,fd,pipe,http,https,rtp,tcp,udp
             --disable-muxers
             --enable-muxer=rtp
             --disable-encoders
             --disable-decoders
             --enable-decoder=*aac*,h264*,mp3*,mjpeg,rv*
             --disable-demuxers
-            --enable-demuxer=h264,mp3,mov
+            --enable-demuxer=h264,mp3,mov,mpjpeg,rtsp,sdp
             --disable-zlib
             --disable-avdevice
         BUILD_IN_SOURCE ON

deps/NLopt/NLopt.cmake

@@ -8,8 +8,6 @@ orcaslicer_add_cmake_project(NLopt
     -DNLOPT_GUILE:BOOL=OFF
     -DNLOPT_SWIG:BOOL=OFF
     -DNLOPT_TESTS:BOOL=OFF
-    # testopt is built regardless of NLOPT_TESTS; see deps-windows.cmake.
-    "${DEP_LLD_FORCE_MULTIPLE}"
 )
 
 if (MSVC)

deps/OpenSSL/OpenSSL.cmake

@@ -80,12 +80,6 @@ ExternalProject_Add(dep_OpenSSL
     INSTALL_COMMAND ${_install_cmd}
 )
 
-if (CMAKE_GENERATOR MATCHES "Visual Studio")
-    # OpenSSL builds with cl, but MSBuild runs nmake in this project's toolset
-    # environment, and ClangCL's puts clang's headers first. Use the default.
-    set_target_properties(dep_OpenSSL PROPERTIES VS_PLATFORM_TOOLSET "$(DefaultPlatformToolset)")
-endif ()
-
 ExternalProject_Add_Step(dep_OpenSSL install_cmake_files
     DEPENDEES install
 

deps/deps-windows.cmake

@@ -42,15 +42,6 @@ else ()
     message(FATAL_ERROR "Unsupported OS architecture: ${DEPS_ARCH}")
 endif ()
 
-# Draco's tools and NLopt's testopt compile sources that are also in their
-# static library. MSBuild passes the library before the objects and lld-link
-# resolves as it goes, so the library's copy wins and the object then reads as
-# a duplicate. Nothing uses those executables, so let lld keep the first one.
-set(DEP_LLD_FORCE_MULTIPLE "")
-if (CMAKE_GENERATOR MATCHES "Visual Studio" AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    set(DEP_LLD_FORCE_MULTIPLE "-DCMAKE_EXE_LINKER_FLAGS:STRING=${CMAKE_EXE_LINKER_FLAGS} /FORCE:MULTIPLE")
-endif ()
-
 if (${DEP_DEBUG})
     set(DEP_BOOST_DEBUG "debug")
 else ()

resources/web/dialog/PluginsDialog/index.js

@@ -575,7 +575,7 @@ function CapabilityCanRun(plugin, capability) {
 }
 
 function IsPluginChecked(plugin) {
-  return GetStatus(plugin) === "Activated";
+  return plugin.is_loaded;
 }
 
 function HasMixedCapabilityState(plugin) {
@@ -1347,6 +1347,8 @@ function StatusDescription(plugin) {
       return "This plugin is still loading.";
     case "Error":
       return "This plugin is blocked until its error is fixed.";
+    case "RuntimeError":
+      return "This plugin is loaded but a capability reported an error.";
     case "Inactive":
     default:
       return "This plugin is inactive. Activate it to install or load it.";

resources/web/dialog/PluginsDialog/styles.css

@@ -424,6 +424,11 @@ body.pane-resizing {
   font-weight: 600;
 }
 
+.status-cell.status-runtimeerror {
+  color: var(--plugin-status-warn);
+  font-weight: 600;
+}
+
 .status-cell.status-loading {
   color: var(--plugin-status-warn);
   font-weight: 600;
@@ -680,6 +685,11 @@ body.pane-resizing {
   color: var(--plugin-status-danger);
 }
 
+.detail-status-chip.status-runtimeerror {
+  background: var(--plugin-status-warn-bg);
+  color: var(--plugin-status-warn);
+}
+
 .detail-status-chip.status-loading {
   background: var(--plugin-status-warn-bg);
   color: var(--plugin-status-warn);

scripts/flatpak/com.orcaslicer.OrcaSlicer.yml

@@ -325,6 +325,13 @@ modules:
         sha256: deedcabe339165214a3637df4c86a507aef0d793cf8774ff68735f4737e8ddbc
         dest: external-packages/FFMPEG
 
+      # libdatachannel v0.22.2
+      - type: git
+        url: https://github.com/paullouisageneau/libdatachannel.git
+        tag: v0.22.2
+        commit: b3390b4e01e97071dd054684870c4bb5221794bf
+        dest: deps/build_flatpak/dep_DataChannel-prefix/src/dep_DataChannel
+
       # ---------------------------------------------------------------
       # Fallback archives for deps normally provided by the GNOME SDK.
       # These are only used if find_package() fails to locate them.

scripts/test_moonraker_lane_data.py

@@ -24,7 +24,7 @@ NAMESPACE = "lane_data"
 
 # Repo-relative paths for the offline generic-map check
 REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-MOONRAKER_AGENT_CPP = os.path.join(REPO_ROOT, "src", "slic3r", "Utils", "MoonrakerPrinterAgent.cpp")
+AMS_PAYLOAD_CPP = os.path.join(REPO_ROOT, "src", "slic3r", "Utils", "AmsPayload.cpp")
 OFL_FILAMENT_DIR = os.path.join(REPO_ROOT, "resources", "profiles", "OrcaFilamentLibrary", "filament")
 LANE_KEYS = [f"lane{i}" for i in range(1, 9)]  # lane1-lane8
 MATERIALS = ["PLA", "ABS", "PETG", "ASA", "ASA Sparkle", "TPU", ""]
@@ -41,16 +41,16 @@ MATERIAL_TEMPS = {
 }
 
 def parse_cpp_type_map():
-    """Extract the normalized-type -> OFL generic family table from MoonrakerPrinterAgent.cpp.
+    """Extract the normalized-type -> OFL generic family table from AmsPayload.cpp.
 
-    Reads MoonrakerPrinterAgent::map_filament_type_to_generic_id's type_to_ofl_family
-    initializer so the check tracks the C++ normalization without a duplicated list.
+    Reads map_filament_type_to_generic_id's type_to_ofl_family initializer so the
+    check tracks the C++ normalization without a duplicated list.
     """
-    with open(MOONRAKER_AGENT_CPP, encoding="utf-8") as f:
+    with open(AMS_PAYLOAD_CPP, encoding="utf-8") as f:
         src = f.read()
     m = re.search(r"type_to_ofl_family\s*=\s*\{(.*?)\n\s*\};", src, re.DOTALL)
     if not m:
-        raise RuntimeError(f"type_to_ofl_family table not found in {MOONRAKER_AGENT_CPP}")
+        raise RuntimeError(f"type_to_ofl_family table not found in {AMS_PAYLOAD_CPP}")
     pairs = re.findall(r'\{\s*"([^"]+)"\s*,\s*"([^"]+)"\s*\}', m.group(1))
     if not pairs:
         raise RuntimeError("type_to_ofl_family table parsed empty")

src/OrcaSlicer.cpp

@@ -87,7 +87,6 @@ using namespace nlohmann;
 #include "dev-utils/BaseException.h"
 #endif
 #include "slic3r/Utils/MeshInspect.hpp"
-#include "slic3r/Utils/PaintCLI.hpp"
 #include "slic3r/GUI/PartPlate.hpp"
 #include "slic3r/GUI/BitmapCache.hpp"
 #include "slic3r/GUI/OpenGLManager.hpp"
@@ -1444,29 +1443,6 @@ int CLI::run(int argc, char **argv)
         }
     }
 
-    // --inspect-paint prints its JSON and exits, so any action that does work of its
-    // own (slicing, exporting) would be skipped without notice. Reject those up front;
-    // only options that merely tune how the input is loaded may come along.
-    if (std::find(m_actions.begin(), m_actions.end(), "inspect_paint") != m_actions.end()) {
-        static const std::set<std::string> inspect_compatible = { "inspect_paint", "uptodate", "load_defaultfila", "min_save",
-                                                                  "mtcpp", "mstpp", "no_check", "normative_check", "pipe" };
-        for (const std::string &action : m_actions) {
-            if (inspect_compatible.count(action) == 0) {
-                std::string flag = action;
-                std::replace(flag.begin(), flag.end(), '_', '-');
-                boost::nowide::cerr << "--inspect-paint cannot be combined with --" << flag << std::endl;
-                record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
-                flush_and_exit(CLI_INVALID_PARAMS);
-            }
-        }
-        // Without input there is nothing to inspect; fail rather than print nothing and exit 0.
-        if (m_input_files.empty() && m_config.opt_string("load_assemble_list").empty()) {
-            boost::nowide::cerr << "--inspect-paint needs an input file or --load-assemble-list" << std::endl;
-            record_exit_reson(outfile_dir, CLI_INVALID_PARAMS, 0, cli_errors[CLI_INVALID_PARAMS], sliced_info);
-            flush_and_exit(CLI_INVALID_PARAMS);
-        }
-    }
-
     // --export-settings - writes its JSON to stdout, so reject every action or transform that may write there
     // too (--info, --help, --orient, slicing and exporting). The allowed ones do nothing when nothing is
     // sliced or exported.
@@ -6124,30 +6100,6 @@ int CLI::run(int argc, char **argv)
                 cli_status_callback(slicing_status);
             }
             g_cli_callback_mgr.stop();
-#endif
-            for (Model &m : m_models)
-                m.remove_backup_path_if_exist();
-            record_exit_reson(outfile_dir, CLI_SUCCESS, plate_to_slice, cli_errors[CLI_SUCCESS], sliced_info);
-            boost::nowide::cerr.flush();
-            return CLI_SUCCESS;
-        } else if (opt_key == "inspect_paint") {
-            // --inspect-paint — read the per-facet enforcer/blocker/extruder/
-            // fuzzy state from the loaded model and emit a JSON summary.
-            // Machine-readable alternative to opening the paint gizmos.
-            for (Model &model : m_models) {
-                model.add_default_instances();
-                Slic3r::PaintCLI::inspect_to_json(model, m_input_files, boost::nowide::cout);
-            }
-            boost::nowide::cout.flush();
-            // The tooltip promises "then exit"; conflicting actions were rejected before
-            // loading. Finish like the end of run(). flush_and_exit() is not usable here:
-            // it prints "found error ..." to stdout, which would corrupt the JSON.
-#if defined(__linux__) || defined(__LINUX__)
-            if (g_cli_callback_mgr.is_started()) {
-                PrintBase::SlicingStatus slicing_status{100, "All done, Success"};
-                cli_status_callback(slicing_status);
-            }
-            g_cli_callback_mgr.stop();
 #endif
             for (Model &m : m_models)
                 m.remove_backup_path_if_exist();

src/libslic3r/GCode/ToolOrdering.cpp

@@ -2735,28 +2735,6 @@ void ToolOrdering::enforce_mixed_component_order()
     }
 }
 
-// Declared in ToolOrdering.hpp (exposed for unit testing).
-std::vector<unsigned int> parse_cyclic_order(const std::string& str, unsigned int number_of_extruders)
-{
-    std::vector<unsigned int> order;
-    for (const std::string& token : split_string(str, ',')) {
-        try {
-            size_t pos      = 0;
-            int    filament = std::stoi(token, &pos); // stoi skips leading whitespace by itself
-            // stoi stops at the first non-digit, so "2x" would parse as 2. Require the whole token to be
-            // consumed (bar trailing whitespace) to drop it like any other garbage.
-            if (token.find_first_not_of(" \t\r\n", pos) != std::string::npos)
-                continue;
-            if (filament >= 1 && (unsigned int)filament <= number_of_extruders
-                && std::find(order.begin(), order.end(), (unsigned int)(filament - 1)) == order.end())
-                order.emplace_back((unsigned int)(filament - 1));
-        } catch (const std::exception&) {
-            // Not a number, ignore it.
-        }
-    }
-    return order;
-}
-
 void ToolOrdering::reorder_extruders_for_minimum_flush_volume(bool reorder_first_layer)
 {
     const PrintConfig* print_config = m_print_config_ptr;
@@ -2854,41 +2832,11 @@ void ToolOrdering::reorder_extruders_for_minimum_flush_volume(bool reorder_first
     const bool use_cyclic_ordering =
         (print_config->toolchange_ordering == ToolChangeOrderingType::Cyclic);
 
-    // By default the first layer keeps its adhesion-optimized order (and any custom first layer
-    // sequence); the cyclic sequence is only forced onto it when the user opts in.
-    const bool cyclic_first_layer = use_cyclic_ordering && print_config->toolchange_cyclic_first_layer.value;
-
-    // Optional user defined cyclic sequence, given as 1-based filament numbers ("3,2,1,4"). Filaments
-    // missing from it keep their ascending order after the listed ones, so a partial or bogus entry
-    // still yields the default cyclic order.
-    const std::vector<unsigned int> cyclic_order =
-        use_cyclic_ordering ? parse_cyclic_order(print_config->toolchange_cyclic_order.value, number_of_extruders)
-                            : std::vector<unsigned int>();
-
-    // Reorder a layer's filaments (0-based) for cyclic ordering: ascending by default, or following the
-    // user defined sequence when one was given. Filaments absent from the sequence keep ascending order
-    // after the listed ones.
-    auto apply_cyclic_order = [&cyclic_order](std::vector<unsigned int>& filaments) {
-        std::sort(filaments.begin(), filaments.end());
-        if (!cyclic_order.empty())
-            std::stable_sort(filaments.begin(), filaments.end(), [&cyclic_order](unsigned int lhs, unsigned int rhs) {
-                auto rank = [&cyclic_order](unsigned int filament) {
-                    return size_t(std::find(cyclic_order.begin(), cyclic_order.end(), filament) - cyclic_order.begin());
-                };
-                return rank(lhs) < rank(rhs);
-            });
-    };
-
     // other_layers_seq: the layer_idx and extruder_idx are base on 1
-    auto get_custom_seq = [&other_layers_seqs, &reorder_first_layer, &first_layer_filaments, &layer_filaments, use_cyclic_ordering, cyclic_first_layer, &apply_cyclic_order](int layer_idx, std::vector<int>& out_seq) -> bool {
+    auto get_custom_seq = [&other_layers_seqs, &reorder_first_layer, &first_layer_filaments, &layer_filaments, use_cyclic_ordering](int layer_idx, std::vector<int>& out_seq) -> bool {
         if (!reorder_first_layer && layer_idx == 0) {
-            // The first layer tool order is already decided (adhesion-optimized, plus any custom first
-            // layer sequence). Only override it with the cyclic sequence when the user opted in.
-            std::vector<unsigned int> ordered = first_layer_filaments;
-            if (cyclic_first_layer)
-                apply_cyclic_order(ordered);
-            out_seq.resize(ordered.size());
-            std::transform(ordered.begin(), ordered.end(), out_seq.begin(), [](auto item) {return int(item) + 1; });
+            out_seq.resize(first_layer_filaments.size());
+            std::transform(first_layer_filaments.begin(), first_layer_filaments.end(), out_seq.begin(), [](auto item) {return item + 1; });
             return true;
         }
         for (size_t idx = other_layers_seqs.size() - 1; idx != size_t(-1); --idx) {
@@ -2899,12 +2847,9 @@ void ToolOrdering::reorder_extruders_for_minimum_flush_volume(bool reorder_first
             }
         }
 
-        // Skip the first layer here (layer_idx == 0 only reaches this point on the reorder_first_layer
-        // path) unless the user asked for cyclic order on it, so it keeps the default flush ordering.
-        if (use_cyclic_ordering && layer_idx >= 0 && (layer_idx != 0 || cyclic_first_layer)
-            && size_t(layer_idx) < layer_filaments.size()) {
+        if (use_cyclic_ordering && layer_idx >= 0 && size_t(layer_idx) < layer_filaments.size()) {
             std::vector<unsigned int> ordered = layer_filaments[size_t(layer_idx)];
-            apply_cyclic_order(ordered);
+            std::sort(ordered.begin(), ordered.end());
             out_seq.resize(ordered.size());
             std::transform(ordered.begin(), ordered.end(), out_seq.begin(), [](auto item) { return int(item) + 1; });
             return true;

src/libslic3r/GCode/ToolOrdering.hpp

@@ -417,11 +417,6 @@ private:
     int                        most_used_extruder;
 };
 
-// Parse the user defined cyclic toolchange sequence ("3,2 , 1 , 4") into 0-based filament indices.
-// Out-of-range entries, duplicates and non-numeric tokens are dropped, so a partially valid string
-// still orders the filaments it does name. Exposed for unit testing.
-std::vector<unsigned int> parse_cyclic_order(const std::string& str, unsigned int number_of_extruders);
-
 } // namespace SLic3r
 
 #endif /* slic3r_ToolOrdering_hpp_ */

src/libslic3r/Preset.cpp

@@ -1320,8 +1320,6 @@ static std::vector<std::string> s_Preset_print_options{
     "wipe_tower_extra_flow",
     "single_extruder_multi_material_priming",
     "toolchange_ordering",
-    "toolchange_cyclic_order",
-    "toolchange_cyclic_first_layer",
     "wipe_tower_rotation_angle",
     "tree_support_branch_distance_organic",
     "tree_support_branch_diameter_organic",

src/libslic3r/PresetBundle.cpp

@@ -3824,7 +3824,6 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
     ConfigOptionStrings *filament_color_type = project_config.option<ConfigOptionStrings>("filament_colour_type");
     ConfigOptionInts *   filament_map = project_config.option<ConfigOptionInts>("filament_map");
     ConfigOptionInts *   filament_volume_map = project_config.option<ConfigOptionInts>("filament_volume_map");
-
     // Snapshot and temporarily strip mixed filament slots so AMS sync operates on physical
     // filaments only. A mixed slot is virtual and has no tray to sync against; leaving it in
     // would let AMS mapping overwrite it and would break the physical-first slot ordering the

src/libslic3r/Print.cpp

@@ -360,8 +360,6 @@ bool Print::invalidate_state_by_config_options(const ConfigOptionResolver & /* n
             || opt_key == "other_layers_print_sequence"
             || opt_key == "other_layers_print_sequence_nums" 
             || opt_key == "toolchange_ordering"
-            || opt_key == "toolchange_cyclic_order"
-            || opt_key == "toolchange_cyclic_first_layer"
             || opt_key == "extruder_ams_count"
             || opt_key == "extruder_nozzle_stats"
             || opt_key == "filament_map_mode"

src/libslic3r/PrintConfig.cpp

@@ -6700,34 +6700,6 @@ void PrintConfigDef::init_fff_params()
     def->enum_labels.emplace_back(L("Cyclic"));
     def->set_default_value(new ConfigOptionEnum<ToolChangeOrderingType>(ToolChangeOrderingType::Default));
 
-    def = this->add("toolchange_cyclic_order", coString);
-    def->label = L("Cyclic order");
-    def->category = L("Advanced");
-    def->tooltip = L(
-        "Custom filament sequence used by the cyclic toolchange ordering, as filament numbers separated by commas (e.g. \"3,2,1,4\").\n"
-        "Each layer prints its filaments following this sequence; filaments not listed are printed last, in ascending order.\n"
-        "Leave empty to cycle through the filaments in ascending order."
-    );
-    def->mode = comExpert;
-    def->set_default_value(new ConfigOptionString(""));
-
-    def = this->add("toolchange_cyclic_first_layer", coBool);
-    def->label = L("Apply cyclic order to first layer");
-    def->category = L("Advanced");
-    def->tooltip = L(
-        "Applies the cyclic toolchange order to the first layer as well.\n"
-        "By default this is disabled, because the first layer is instead ordered for the best bed "
-        "adhesion: filaments that print small, fragile first-layer features are printed last, so the "
-        "following tool changes and travel moves are less likely to knock those weakly anchored parts "
-        "loose. This first-layer order also honors a custom first layer filament sequence when one is set. "
-        "The cyclic order's benefit (extra tool changes give each layer more time to cool) does not apply "
-        "to the first layer, which is printed slowly and hot for adhesion.\n"
-        "Enable this only if you need the exact same tool sequence on every layer, including the first, at "
-        "the cost of that adhesion optimization."
-    );
-    def->mode = comExpert;
-    def->set_default_value(new ConfigOptionBool(false));
-
     def = this->add("slice_closing_radius", coFloat);
     def->label = L("Slice gap closing radius");
     def->category = L("Quality");
@@ -11991,19 +11963,6 @@ CLIActionsConfigDef::CLIActionsConfigDef()
                      "the --ground-* options choose from. Machine-readable alternative to --info.");
     def->set_default_value(new ConfigOptionBool(false));
 
-    // --inspect-paint \u2014 dump the per-facet enforcer/blocker/extruder/fuzzy
-    // paint state stored on the loaded model (supports, seam, MMU color,
-    // fuzzy-skin) as JSON. Read-only; lets CI / scripted / AI tooling
-    // reason about existing paint on a .3mf without loading the GUI.
-    def = this->add("inspect_paint", coBool);
-    def->label = L("Inspect paint (JSON to stdout)");
-    def->tooltip = L("Print a structured JSON summary of every painted layer "
-                     "(supports, seam, MMU color, fuzzy-skin) already stored on "
-                     "the loaded model \u2014 per-state facet count, surface area, "
-                     "and mesh-local bounding box \u2014 then exit. Machine-readable "
-                     "alternative to opening the paint gizmos in the GUI.");
-    def->set_default_value(new ConfigOptionBool(false));
-
     def = this->add("export_settings", coString);
     def->label = L("Export Settings");
     def->tooltip = L("This exports settings to a file. Use - to write them to stdout.");

src/libslic3r/PrintConfig.hpp

@@ -1627,8 +1627,6 @@ PRINT_CONFIG_CLASS_DEFINE(
     ((ConfigOptionBool,                manual_filament_change))
     ((ConfigOptionBool,                single_extruder_multi_material_priming))
     ((ConfigOptionEnum<ToolChangeOrderingType>, toolchange_ordering))
-    ((ConfigOptionString,              toolchange_cyclic_order))
-    ((ConfigOptionBool,                toolchange_cyclic_first_layer))
     ((ConfigOptionBool,                wipe_tower_no_sparse_layers))
     ((ConfigOptionString,              change_filament_gcode))
     ((ConfigOptionString,              change_extrusion_role_gcode))

src/slic3r/CMakeLists.txt

@@ -226,6 +226,7 @@ set(SLIC3R_GUI_SOURCES
     GUI/GLToolbar.hpp
     GUI/ImageDPIFrame.cpp
     GUI/ImageDPIFrame.hpp
+    GUI/IMediaController.hpp
     GUI/GUI_App.cpp
     GUI/GUI_App.hpp
     GUI/GUI_AuxiliaryList.cpp
@@ -347,6 +348,8 @@ set(SLIC3R_GUI_SOURCES
     GUI/MediaFilePanel.h
     GUI/MediaPlayCtrl.cpp
     GUI/MediaPlayCtrl.h
+    GUI/WebRtcMediaController.cpp
+    GUI/WebRtcMediaController.hpp
     GUI/MeshUtils.cpp
     GUI/MeshUtils.hpp
     GUI/ModelMall.cpp
@@ -536,6 +539,8 @@ set(SLIC3R_GUI_SOURCES
     GUI/WebUserLoginDialog.hpp
     GUI/WebViewDialog.cpp
     GUI/WebViewDialog.hpp
+    GUI/WebMediaController.hpp
+    GUI/WebMediaController.cpp
     GUI/Widgets/AMSControl.cpp
     GUI/Widgets/AMSControl.hpp
     GUI/Widgets/AMSItem.cpp
@@ -682,8 +687,6 @@ set(SLIC3R_GUI_SOURCES
     Utils/Bonjour.hpp
     Utils/MeshInspect.cpp
     Utils/MeshInspect.hpp
-    Utils/PaintCLI.cpp
-    Utils/PaintCLI.hpp
     Utils/CalibUtils.cpp
     Utils/CalibUtils.hpp
     Utils/ColorSpaceConvert.cpp
@@ -730,10 +733,17 @@ set(SLIC3R_GUI_SOURCES
     Utils/NetworkAgentFactory.cpp
     Utils/ICloudServiceAgent.hpp
     Utils/IPrinterAgent.hpp
+    Utils/ICameraSignalingChannel.hpp
     Utils/OrcaCloudServiceAgent.cpp
     Utils/OrcaCloudServiceAgent.hpp
+    Utils/OrcaMqttConnection.cpp
+    Utils/OrcaMqttConnection.hpp
     Utils/OrcaPrinterAgent.cpp
     Utils/OrcaPrinterAgent.hpp
+    Utils/AmsPayload.cpp
+    Utils/AmsPayload.hpp
+    Utils/OrcaCloudSignalingChannel.cpp
+    Utils/OrcaCloudSignalingChannel.hpp
     Utils/QidiPrinterAgent.cpp
     Utils/QidiPrinterAgent.hpp
     Utils/SnapmakerPrinterAgent.cpp
@@ -874,7 +884,7 @@ else()
     set(_opengl_link_lib OpenGL::GL)
 endif()
 
-target_link_libraries(libslic3r_gui libslic3r cereal::cereal imgui imguizmo minilzo libvgcode md4c-html glad ${_opengl_link_lib} hidapi mdns ${wxWidgets_LIBRARIES} glfw libcurl OpenSSL::SSL OpenSSL::Crypto noise::noise pybind11::embed)
+target_link_libraries(libslic3r_gui libslic3r cereal::cereal imgui imguizmo minilzo libvgcode md4c-html glad ${_opengl_link_lib} hidapi mdns ${wxWidgets_LIBRARIES} glfw libcurl OpenSSL::SSL OpenSSL::Crypto LibDataChannel::LibDataChannel noise::noise pybind11::embed)
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
     # Linux finds wxWidgets in module mode, whose include dirs and definitions
@@ -931,29 +941,32 @@ endif ()
 
 if (APPLE)
     # Static FFmpeg from the deps install: nothing to bundle into the .app,
-    # no rpath/install_name handling. Order matters: avcodec -> swscale -> avutil.
+    # no rpath/install_name handling. Order matters: avformat -> avcodec -> swscale -> avutil.
+    find_library(LIBAVFORMAT_LIBRARY NAMES libavformat.a PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBAVCODEC_LIBRARY NAMES libavcodec.a PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBSWSCALE_LIBRARY NAMES libswscale.a PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBAVUTIL_LIBRARY NAMES libavutil.a PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
-    if (NOT LIBAVCODEC_LIBRARY OR NOT LIBSWSCALE_LIBRARY OR NOT LIBAVUTIL_LIBRARY)
-        message(FATAL_ERROR "Static FFmpeg (libavcodec.a/libswscale.a/libavutil.a) not found under ${CMAKE_PREFIX_PATH}/lib. Rebuild the deps — FFMPEG builds static-only on macOS.")
+    if (NOT LIBAVFORMAT_LIBRARY OR NOT LIBAVCODEC_LIBRARY OR NOT LIBSWSCALE_LIBRARY OR NOT LIBAVUTIL_LIBRARY)
+        message(FATAL_ERROR "Static FFmpeg (libavformat.a/libavcodec.a/libswscale.a/libavutil.a) not found under ${CMAKE_PREFIX_PATH}/lib. Rebuild the deps — FFMPEG builds static-only on macOS.")
     endif ()
-    target_link_libraries(libslic3r_gui ${LIBAVCODEC_LIBRARY} ${LIBSWSCALE_LIBRARY} ${LIBAVUTIL_LIBRARY})
+    target_link_libraries(libslic3r_gui ${LIBAVFORMAT_LIBRARY} ${LIBAVCODEC_LIBRARY} ${LIBSWSCALE_LIBRARY} ${LIBAVUTIL_LIBRARY})
     target_include_directories(libslic3r_gui SYSTEM PRIVATE ${CMAKE_PREFIX_PATH}/include)
 elseif (WIN32)
     # Prebuilt shared FFmpeg from the deps install. Windows has no pkg-config,
     # so resolve the import libraries out of the deps prefix directly; the DLLs
     # are copied next to the executable by the top level CMakeLists.
+    find_library(LIBAVFORMAT_LIBRARY NAMES avformat PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBAVCODEC_LIBRARY NAMES avcodec PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBSWSCALE_LIBRARY NAMES swscale PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     find_library(LIBAVUTIL_LIBRARY NAMES avutil PATHS ${CMAKE_PREFIX_PATH}/lib NO_DEFAULT_PATH)
     if (NOT LIBAVCODEC_LIBRARY OR NOT LIBSWSCALE_LIBRARY OR NOT LIBAVUTIL_LIBRARY)
         message(FATAL_ERROR "FFmpeg (avcodec/swscale/avutil) not found under ${CMAKE_PREFIX_PATH}/lib. Rebuild the deps.")
     endif ()
-    target_link_libraries(libslic3r_gui ${LIBAVCODEC_LIBRARY} ${LIBSWSCALE_LIBRARY} ${LIBAVUTIL_LIBRARY})
+    target_link_libraries(libslic3r_gui ${LIBAVFORMAT_LIBRARY} ${LIBAVCODEC_LIBRARY} ${LIBSWSCALE_LIBRARY} ${LIBAVUTIL_LIBRARY})
     target_include_directories(libslic3r_gui SYSTEM PRIVATE ${CMAKE_PREFIX_PATH}/include)
 else ()
     pkg_check_modules(LIBAV REQUIRED IMPORTED_TARGET
+        libavformat
         libavcodec
         libswscale
         libavutil

src/slic3r/GUI/AVVideoDecoder.cpp

@@ -45,6 +45,25 @@ int AVVideoDecoder::open(Bambu_StreamInfo const &info)
     return 0;
 }
 
+int AVVideoDecoder::open(AVCodecParameters const &parameters)
+{
+    if (avcodec_parameters_to_context(codec_ctx_, &parameters) < 0)
+        return -1;
+
+    auto codec = avcodec_find_decoder(codec_ctx_->codec_id);
+    if (codec == nullptr) {
+        fprintf(stderr, "AVVideoDecoder: unsupported codec!\n");
+        return -1;
+    }
+    if (avcodec_open2(codec_ctx_, codec, nullptr) < 0) {
+        fprintf(stderr, "AVVideoDecoder: could not open codec\n");
+        return -1;
+    }
+
+    frame_ = av_frame_alloc();
+    return frame_ == nullptr ? -1 : 0;
+}
+
 int AVVideoDecoder::decode(const Bambu_Sample &sample)
 {
     int ret = -1;
@@ -71,6 +90,14 @@ int AVVideoDecoder::decode(const Bambu_Sample &sample)
     return ret;
 }
 
+int AVVideoDecoder::decode(const AVPacket &packet)
+{
+    int ret = avcodec_send_packet(codec_ctx_, &packet);
+    if (ret == 0)
+        got_frame_ = avcodec_receive_frame(codec_ctx_, frame_) == 0;
+    return ret;
+}
+
 int AVVideoDecoder::flush()
 {
     int ret = avcodec_send_packet(codec_ctx_, nullptr);

src/slic3r/GUI/AVVideoDecoder.hpp

@@ -23,8 +23,10 @@ public:
 
 public:
     int  open(Bambu_StreamInfo const &info);
+    int  open(AVCodecParameters const &parameters);
 
     int  decode(Bambu_Sample const &sample);
+    int  decode(AVPacket const &packet);
 
     int  flush();
 
@@ -34,6 +36,14 @@ public:
 
     bool toWxBitmap(wxBitmap &bitmap, wxSize const & size);
 
+    // Native size of the most recently decoded frame, or an unspecified size if
+    // nothing has decoded yet. Lets a caller learn the video dimensions when the
+    // container/probe could not report them up front.
+    wxSize decoded_frame_size() const
+    {
+        return got_frame_ && frame_ ? wxSize{frame_->width, frame_->height} : wxSize{};
+    }
+
 private:
     AVCodecContext *codec_ctx_ = nullptr;
     AVFrame *       frame_     = nullptr;

src/slic3r/GUI/CalibrationPanel.cpp

@@ -328,7 +328,7 @@ void SelectMObjectPopup::update_user_devices()
     }
 
     m_bind_machine_list.clear();
-    m_bind_machine_list = dev->get_my_machine_list();
+    m_bind_machine_list = dev->get_my_machine_list(dev->get_current_printer_agent_id());
 
     //sort list
     std::vector<std::pair<std::string, MachineObject*>> user_machine_list;

src/slic3r/GUI/CalibrationWizardPresetPage.cpp

@@ -8,6 +8,7 @@
 #include "libslic3r/Print.hpp"
 
 #include "DeviceCore/DevConfig.h"
+#include "DeviceCore/DevConfigUtil.h"
 #include "DeviceCore/DevExtruderSystem.h"
 #include "DeviceCore/DevFilaBlackList.h"
 #include "DeviceCore/DevFilaSystem.h"
@@ -1647,18 +1648,8 @@ bool CalibrationPresetPage::is_blocking_printing()
     if (obj_ == nullptr) return true;
 
     PresetBundle* preset_bundle = wxGetApp().preset_bundle;
-    auto source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
-    auto target_model = obj_->printer_type;
-
-    if (source_model != target_model) {
-        std::vector<std::string> compatible_machine = obj_->get_compatible_machine();
-        vector<std::string>::iterator it = find(compatible_machine.begin(), compatible_machine.end(), source_model);
-        if (it == compatible_machine.end()) {
-            return true;
-        }
-    }
-
-    return false;
+    const auto source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
+    return !DevPrinterConfigUtil::is_printer_model_compatible(source_model, *obj_);
 }
 
 bool CalibrationPresetPage::is_nozzle_info_synced() const

src/slic3r/GUI/CameraPopup.cpp

@@ -28,7 +28,6 @@ wxEND_EVENT_TABLE()
 
 wxDEFINE_EVENT(EVT_VCAMERA_SWITCH, wxMouseEvent);
 wxDEFINE_EVENT(EVT_SDCARD_ABSENT_HINT, wxCommandEvent);
-wxDEFINE_EVENT(EVT_CAM_SOURCE_CHANGE, wxCommandEvent);
 
 #define CAMERAPOPUP_CLICK_INTERVAL 20
 
@@ -82,7 +81,7 @@ CameraPopup::CameraPopup(wxWindow *parent)
     top_sizer->Add(m_text_liveview_retry, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT | wxALL, FromDIP(5));
     top_sizer->Add(m_switch_liveview_retry, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT | wxALL, FromDIP(5));
 
-    m_switch_liveview_retry->Bind(wxEVT_TOGGLEBUTTON, [this](wxCommandEvent &e) {
+    m_switch_liveview_retry->Bind(wxEVT_TOGGLEBUTTON, [](wxCommandEvent &e) {
         wxGetApp().app_config->set("liveview", "auto_retry", e.IsChecked());
         e.Skip();
     });
@@ -102,34 +101,6 @@ CameraPopup::CameraPopup(wxWindow *parent)
         top_sizer->Add(0, 0, wxALL, 0);
     }
 
-    // Orca: custom IP camera source — lets the user point Live Video at any camera URL (Orca feature; not in the reference)
-    m_custom_camera_input_confirm = new Button(m_panel, _L("Enable"));
-    m_custom_camera_input_confirm->SetBackgroundColor(wxColour(38, 166, 154));
-    m_custom_camera_input_confirm->SetBorderColor(wxColour(38, 166, 154));
-    m_custom_camera_input_confirm->SetTextColor(wxColour(0xFFFFFE));
-    m_custom_camera_input_confirm->SetFont(Label::Body_14);
-    m_custom_camera_input_confirm->SetMinSize(wxSize(FromDIP(90), FromDIP(30)));
-    m_custom_camera_input_confirm->SetPosition(wxDefaultPosition);
-    m_custom_camera_input_confirm->SetCornerRadius(FromDIP(12));
-    m_custom_camera_input = new TextInput(m_panel, wxEmptyString, wxEmptyString, wxEmptyString, wxDefaultPosition, wxDefaultSize);
-    m_custom_camera_input->GetTextCtrl()->SetHint(_L("Hostname or IP"));
-    m_custom_camera_input->GetTextCtrl()->SetFont(Label::Body_14);
-    m_custom_camera_hint = new wxStaticText(m_panel, wxID_ANY, _L("Custom camera source"));
-    m_custom_camera_hint->Wrap(-1);
-    m_custom_camera_hint->SetFont(Label::Head_14);
-    m_custom_camera_hint->SetForegroundColour(TEXT_COL);
-
-    m_custom_camera_input_confirm->Bind(wxEVT_BUTTON, &CameraPopup::on_camera_source_changed, this);
-
-    if (!wxGetApp().app_config->get("camera", "custom_source").empty()) {
-        m_custom_camera_input->GetTextCtrl()->SetValue(wxGetApp().app_config->get("camera", "custom_source"));
-        set_custom_cam_button_state(wxGetApp().app_config->get("camera", "enable_custom_source") == "true");
-    }
-
-    top_sizer->Add(m_custom_camera_hint, 0, wxALIGN_CENTER_VERTICAL | wxALIGN_LEFT | wxALL, FromDIP(5));
-    top_sizer->Add(0, 0, wxALL, 0);
-    top_sizer->Add(m_custom_camera_input, 2, wxALIGN_CENTER_VERTICAL | wxEXPAND | wxALL, FromDIP(5));
-    top_sizer->Add(m_custom_camera_input_confirm, 1, wxALIGN_CENTER_VERTICAL | wxALIGN_RIGHT | wxALL, FromDIP(5));
     main_sizer->Add(top_sizer, 0, wxALL, FromDIP(10));
 
     auto url = wxString(L"https://www.orcaslicer.com/wiki/"); // Orca: neutral wiki link (vendor URL removed)
@@ -184,37 +155,6 @@ void CameraPopup::sdcard_absent_hint()
     GetEventHandler()->ProcessEvent(evt);
 }
 
-void CameraPopup::on_camera_source_changed(wxCommandEvent &event)
-{
-    if (m_obj && !m_custom_camera_input->GetTextCtrl()->IsEmpty()) {
-        handle_camera_source_change();
-    }
-}
-
-void CameraPopup::handle_camera_source_change()
-{
-    m_custom_camera_enabled = !m_custom_camera_enabled;
-
-    set_custom_cam_button_state(m_custom_camera_enabled);
-
-    wxGetApp().app_config->set("camera", "custom_source", m_custom_camera_input->GetTextCtrl()->GetValue().ToStdString());
-    wxGetApp().app_config->set("camera", "enable_custom_source", m_custom_camera_enabled);
-
-    wxCommandEvent evt(EVT_CAM_SOURCE_CHANGE);
-    evt.SetEventObject(this);
-    GetEventHandler()->ProcessEvent(evt);
-}
-
-void CameraPopup::set_custom_cam_button_state(bool state)
-{
-    m_custom_camera_enabled = state;
-    auto stateColour = state ? wxColour(170, 0, 0) : wxColour(38, 166, 154);
-    auto stateText = state ? "Disable" : "Enable";
-    m_custom_camera_input_confirm->SetBackgroundColor(stateColour);
-    m_custom_camera_input_confirm->SetBorderColor(stateColour);
-    m_custom_camera_input_confirm->SetLabel(_L(stateText));
-}
-
 void CameraPopup::on_switch_recording(wxCommandEvent& event)
 {
     if (!m_obj) return;

src/slic3r/GUI/CameraPopup.hpp

@@ -15,14 +15,12 @@
 #include "Widgets/SwitchButton.hpp"
 #include "Widgets/RadioBox.hpp"
 #include "Widgets/PopupWindow.hpp"
-#include "Widgets/TextInput.hpp"
 
 namespace Slic3r {
 namespace GUI {
 
 wxDECLARE_EVENT(EVT_VCAMERA_SWITCH, wxMouseEvent);
 wxDECLARE_EVENT(EVT_SDCARD_ABSENT_HINT, wxCommandEvent);
-wxDECLARE_EVENT(EVT_CAM_SOURCE_CHANGE, wxCommandEvent);
 
 class CameraPopup : public PopupWindow
 {
@@ -53,9 +51,6 @@ protected:
     void on_switch_recording(wxCommandEvent& event);
     void on_set_resolution();
     void sdcard_absent_hint();
-    void on_camera_source_changed(wxCommandEvent& event);
-    void handle_camera_source_change();
-    void set_custom_cam_button_state(bool state);
 
     wxWindow *  create_item_radiobox(wxString title, wxWindow *parent, wxString tooltip, int padding_left);
     void select_curr_radiobox(int btn_idx);
@@ -76,10 +71,10 @@ private:
     wxStaticText* m_text_liveview_retry;
     SwitchButton* m_switch_liveview_retry;
 #endif //BBL_RELEASE_TO_PUBLIC
-    wxStaticText* m_custom_camera_hint;
-    TextInput* m_custom_camera_input;
-    Button* m_custom_camera_input_confirm;
-    bool m_custom_camera_enabled{ false };
+    // wxStaticText* m_custom_camera_hint;
+    // TextInput* m_custom_camera_input;
+    // Button* m_custom_camera_input_confirm;
+    // bool m_custom_camera_enabled{ false };
     wxStaticText* m_text_resolution;
     wxWindow* m_resolution_options[RESOLUTION_OPTIONS_NUM];
     wxScrolledWindow *m_panel;

src/slic3r/GUI/ConfigManipulation.cpp

@@ -1055,10 +1055,6 @@ void ConfigManipulation::toggle_print_fff_options(DynamicPrintConfig *config, in
 
     toggle_line("single_extruder_multi_material_priming", !bSEMM && have_prime_tower && supports_wipe_tower_2);
 
-    bool use_cyclic_ordering = config->opt_enum<ToolChangeOrderingType>("toolchange_ordering") == ToolChangeOrderingType::Cyclic;
-    toggle_line("toolchange_cyclic_order", use_cyclic_ordering);
-    toggle_line("toolchange_cyclic_first_layer", use_cyclic_ordering);
-
     toggle_line("prime_volume",have_prime_tower && (!purge_in_primetower || !bSEMM));
 
     for (auto el : {"flush_into_infill", "flush_into_support", "flush_into_objects"})

src/slic3r/GUI/ConnectPrinter.cpp

@@ -35,7 +35,9 @@ ConnectPrinterDialog::ConnectPrinterDialog(wxWindow *parent, wxWindowID id, cons
     sizer_connect = new wxBoxSizer(wxHORIZONTAL);
 
     m_textCtrl_code = new TextInput(this, wxEmptyString);
-    m_textCtrl_code->GetTextCtrl()->SetMaxLength(10);
+    // OrcaSonar uses a 12-character base32 access code. Keep this field long
+    // enough for it while retaining the existing validation for LAN codes.
+    m_textCtrl_code->GetTextCtrl()->SetMaxLength(12);
     m_textCtrl_code->SetFont(Label::Body_14);
     m_textCtrl_code->SetCornerRadius(FromDIP(5));
     m_textCtrl_code->SetSize(wxSize(FromDIP(330), FromDIP(40)));

src/slic3r/GUI/DeviceCore/DevConfigUtil.cpp

@@ -1,5 +1,7 @@
 #include "DevConfigUtil.h"
 
+#include "slic3r/GUI/DeviceManager.hpp"
+
 #include <wx/dir.h>
 #include <boost/filesystem/operations.hpp>
 #include "../I18N.hpp"
@@ -41,6 +43,19 @@ static void _toolhead_translation_markers()
 
 std::string DevPrinterConfigUtil::m_resource_file_path = "";
 
+bool DevPrinterConfigUtil::is_printer_model_compatible(const std::string& source_model, MachineObject& machine)
+{
+    const std::string& target_model = machine.printer_type;
+    if (is_optional_printer_model_id(source_model) || is_optional_printer_model_id(target_model))
+        return true;
+
+    if (source_model == target_model)
+        return true;
+
+    const auto compatible_machine = machine.get_compatible_machine();
+    return std::find(compatible_machine.begin(), compatible_machine.end(), source_model) != compatible_machine.end();
+}
+
 
 std::map<std::string, std::string> DevPrinterConfigUtil::get_all_model_id_with_name()
 {
@@ -405,4 +420,4 @@ std::string DevPrinterConfigUtil::get_toolhead_display_name(
     return result;
 }
 
-};
+};

src/slic3r/GUI/DeviceCore/DevConfigUtil.h

@@ -25,6 +25,8 @@
 namespace Slic3r
 {
 
+class MachineObject;
+
 /// Toolhead component type (extruder / nozzle / hotend)
 enum class ToolHeadComponent {
     Extruder,
@@ -59,6 +61,10 @@ public:
     /*printer*/
     // info
     static std::map<std::string, std::string> get_all_model_id_with_name();
+    // A printer agent may not know the physical model. Keep that case optional so
+    // model compatibility checks do not turn missing identity into a hard error.
+    static bool is_printer_model_compatible(const std::string& source_model, MachineObject& machine);
+    static bool is_optional_printer_model_id(const std::string& model_id) { return model_id.empty(); }
     static std::string get_printer_type(const std::string& type_str) { return get_value_from_config<std::string>(type_str, "printer_type"); }
     static std::string get_printer_display_name(const std::string& type_str) { return get_value_from_config<std::string>(type_str, "display_name"); }
     static std::string get_printer_series_str(std::string type_str) { return get_value_from_config<std::string>(type_str, "printer_series"); }
@@ -227,4 +233,4 @@ static std::string _parse_printer_type(const std::string &type_str)
     return type_str;
 }
 
-};// namespace Slic3r
+};// namespace Slic3r

src/slic3r/GUI/DeviceCore/DevFilaSystem.cpp

@@ -762,9 +762,9 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                             {
                                 curr_tray->remain = -1;
                             }
-                            if (tray_it->contains("tray_slot_placeholder")) {
-                                curr_tray->is_slot_placeholder = true;
-                            }
+                            // The tray objects are reused across status updates. Reset this
+                            // state when a previously empty slot receives a filament again.
+                            curr_tray->is_slot_placeholder = tray_it->contains("tray_slot_placeholder");
                             int ams_id_int = 0;
                             int tray_id_int = 0;
                             try
@@ -999,4 +999,4 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
     }
 }
 
-}
+}

src/slic3r/GUI/DeviceCore/DevManager.cpp

@@ -3,6 +3,7 @@
 #include <exception>
 
 #include "DevManager.h"
+#include "CloudProvider.hpp"
 #include "DevUtil.h"
 
 // TODO: remove this include
@@ -14,6 +15,8 @@
 
 #include "libslic3r/Time.hpp"
 
+#include "IPrinterAgent.hpp"
+
 using namespace nlohmann;
 
 namespace {
@@ -264,6 +267,10 @@ namespace Slic3r
             /* update userMachineList info */
             auto it = userMachineList.find(dev_id);
             if (it != userMachineList.end()) {
+                // A reused entry may have been created while another printer agent was active.
+                // The response was obtained through the current agent, so move ownership with
+                // the entry; otherwise agent-scoped lists hide it after a preset switch.
+                it->second->printer_agent_id = get_current_printer_agent_id();
                 if (it->second->get_dev_ip() != dev_ip ||
                     it->second->bind_state != bind_state ||
                     it->second->bind_sec_link != sec_link ||
@@ -294,6 +301,9 @@ namespace Slic3r
                 // update properties
                 /* ip changed */
                 obj = it->second;
+                // A reused LAN entry may have been discovered while another printer agent was
+                // active. The current discovery message establishes ownership for this agent.
+                obj->printer_agent_id = get_current_printer_agent_id();
 
                 if (obj->get_dev_ip().compare(dev_ip) != 0) {
                     if ( connection_name.empty() ) {
@@ -405,6 +415,9 @@ namespace Slic3r
         auto           it = localMachineList.find(machine.dev_id);
         if (it != localMachineList.end()) {
             obj = it->second;
+            // insert_local_device is called by the active agent, so a reused entry must follow
+            // that agent as well; otherwise the agent-scoped printer list hides it.
+            obj->printer_agent_id = get_current_printer_agent_id();
         } else {
             obj = new MachineObject(this, m_agent, machine.dev_name, machine.dev_id, machine.dev_ip);
             obj->printer_agent_id = get_current_printer_agent_id();
@@ -497,7 +510,7 @@ namespace Slic3r
 
     MachineObject* DeviceManager::get_my_machine(std::string dev_id)
     {
-        auto list = get_my_machine_list();
+        auto list = get_my_machine_list(get_current_printer_agent_id());
         auto it = list.find(dev_id);
         if (it != list.end())
         {
@@ -534,25 +547,15 @@ namespace Slic3r
         OnSelectedMachineChanged(previous_selected_machine, selected_machine);
     }
 
-    void DeviceManager::clear_other_devices(const std::string& target_agent_id)
+    void DeviceManager::clear_other_devices()
     {
-        // why: on agent swap, keep "My Devices" but drop the transient "Other Devices"
-        // Those belong to the previous agent's network scan; the new agent's start_discovery re-populates its own.
-        //
-        // Also drop "My Devices" stamped by a different agent than the one we're swapping to
-        // (target_agent_id, passed by the caller since the live agent hasn't been repointed yet
-        // at this point): otherwise a device first discovered under agent A survives every swap
-        // with a stale printer_agent_id, stays hidden from every agent's filtered list, and only
-        // gets re-tagged if something happens to delete and re-create it (e.g. account logout).
-        // Dropping it here instead lets the new agent's start_discovery re-insert and re-stamp it
-        // like any other fresh device.
-        const auto my = get_my_machine_list();
+        // Device entries are now scoped by printer_agent_id when they are presented. Keep
+        // agent-owned discoveries across a switch so agents without automatic discovery (and
+        // plugins whose devices have not received an access code yet) do not lose their list.
+        // Entries without an owner are legacy/unscoped and cannot safely be shown.
         for (auto it = localMachineList.begin(); it != localMachineList.end();)
         {
-            const bool is_my_device = my.find(it->first) != my.end();
-            const bool agent_mismatch = !target_agent_id.empty() && it->second &&
-                                         it->second->printer_agent_id != target_agent_id;
-            if (!is_my_device || agent_mismatch)
+            if (!it->second || it->second->printer_agent_id.empty())
             {
                 delete it->second;
                 it = localMachineList.erase(it);
@@ -568,8 +571,22 @@ namespace Slic3r
     {
         BOOST_LOG_TRIVIAL(info) << "set_selected_machine=" << dev_id
             << " cur_selected=" << selected_machine;
-        auto my_machine_list = get_my_machine_list();
+        auto my_machine_list = get_my_machine_list(get_current_printer_agent_id());
         auto it = my_machine_list.find(dev_id);
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: set_selected_machine lookup dev_id=" << dev_id
+                                << " found=" << (it != my_machine_list.end())
+                                << " my_machine_count=" << my_machine_list.size()
+                                << " current_agent=" << get_current_printer_agent_id()
+                                << " provider=" << GUI::wxGetApp().get_printer_cloud_provider();
+        if (it != my_machine_list.end() && it->second) {
+            BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: target machine dev_id=" << it->second->get_dev_id()
+                                    << " printer_agent_id=" << it->second->printer_agent_id
+                                    << " connection_type=" << it->second->connection_type()
+                                    << " dev_connection_type=" << it->second->dev_connection_type;
+        } else {
+            BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: target machine was not found in the current agent's machine list";
+            return false;
+        }
 
         // disconnect last if dev_id difference from previous one
         auto last_selected = my_machine_list.find(selected_machine);
@@ -580,7 +597,9 @@ namespace Slic3r
                 m_agent->disconnect_printer();
             }
             else if (last_selected->second->connection_type() == "cloud") {
-                m_agent->set_user_selected_machine("");
+                const int result = m_agent->set_user_selected_machine("");
+                BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: cleared previous cloud selection dev_id="
+                                        << selected_machine << " result=" << result;
             }
         }
 
@@ -632,7 +651,9 @@ namespace Slic3r
                     {
                         // diff dev_id, cloud => set_user_selected_machine(new)
                         BOOST_LOG_TRIVIAL(info) << "set_selected_machine: select new cloud machine, dev_id =" << dev_id;
-                        m_agent->set_user_selected_machine(dev_id);
+                        const int result = m_agent->set_user_selected_machine(dev_id);
+                        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: set new cloud selection dev_id="
+                                                << dev_id << " result=" << result;
                         it->second->reset();
                     }
                     else
@@ -660,6 +681,8 @@ namespace Slic3r
 
         selected_machine = dev_id;
         record_user_last_machine(selected_machine);
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: DeviceManager selection complete selected_machine="
+                                << selected_machine;
         return true;
     }
 
@@ -690,7 +713,9 @@ namespace Slic3r
             dev_list.push_back(it->first);
             BOOST_LOG_TRIVIAL(trace) << "add_user_subscribe: " << it->first;
         }
-        m_agent->add_subscribe(dev_list);
+        const int result = m_agent->add_subscribe(dev_list);
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: add_user_subscribe count=" << dev_list.size()
+                                << " result=" << result;
     }
 
 
@@ -703,7 +728,9 @@ namespace Slic3r
             dev_list.push_back(it->first);
             BOOST_LOG_TRIVIAL(trace) << "del_user_subscribe: " << it->first;
         }
-        m_agent->del_subscribe(dev_list);
+        const int result = m_agent->del_subscribe(dev_list);
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: del_user_subscribe count=" << dev_list.size()
+                                << " result=" << result;
     }
 
     void DeviceManager::subscribe_device_list(std::vector<std::string> dev_list)
@@ -822,7 +849,23 @@ namespace Slic3r
         try
         {
             json j = json::parse(body);
-            const std::string provider = GUI::wxGetApp().get_printer_cloud_provider();
+
+            const bool has_request_context = j.contains("provider") && j.contains("agent_id") && j.contains("generation");
+            const std::string provider = j.contains("provider") ? j["provider"].get<std::string>()
+                                                                   : GUI::wxGetApp().get_printer_cloud_provider();
+            const std::string agent_id = j.contains("agent_id") ? j["agent_id"].get<std::string>()
+                                                                  : get_current_printer_agent_id();
+            const std::uint64_t generation = j.value("generation", std::uint64_t(0));
+
+            if (has_request_context &&
+                (provider != GUI::wxGetApp().get_printer_cloud_provider() ||
+                 agent_id != get_current_printer_agent_id() ||
+                 generation != (m_agent ? m_agent->get_user_machine_list_generation() : 0))) {
+                BOOST_LOG_TRIVIAL(debug) << __FUNCTION__ << ": ignoring stale response provider="
+                                         << provider << " agent_id=" << agent_id
+                                         << " generation=" << generation;
+                return;
+            }
 
 #if !BBL_RELEASE_TO_PUBLIC
             BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": " << j;
@@ -845,11 +888,14 @@ namespace Slic3r
                         /* update field */
                         obj = iter->second;
                         obj->set_dev_id(dev_id);
+                        // A device can be rediscovered by a different agent after a preset
+                        // switch while retaining the same MachineObject instance.
+                        obj->printer_agent_id = agent_id;
                     }
                     else
                     {
                         obj = new MachineObject(this, m_agent, "", "", "");
-                        obj->printer_agent_id = get_current_printer_agent_id();
+                        obj->printer_agent_id = agent_id;
                         if (m_agent)
                         {
                             obj->set_bind_status(m_agent->get_user_name(provider));
@@ -864,6 +910,12 @@ namespace Slic3r
 
                     if (!obj) continue;
 
+                    // Orca cloud printers are only ever delivered through this REST
+                    // account list; tag them so DeviceManager's cloud/lan branches
+                    // (subscribe + deselect in set_selected_machine) treat them right.
+                    if (provider == ORCA_CLOUD_PROVIDER)
+                        obj->dev_connection_type = "cloud";
+
                     if (!elem["dev_id"].is_null())
                         obj->set_dev_id(elem["dev_id"].get<std::string>());
                     if (!elem["dev_name"].is_null())
@@ -895,6 +947,12 @@ namespace Slic3r
                         acc_code.erase(std::remove(acc_code.begin(), acc_code.end(), '\n'), acc_code.end());
                         obj->set_access_code(acc_code);
                     }
+
+                    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: parsed cloud machine dev_id=" << dev_id
+                                            << " name=" << obj->get_dev_name()
+                                            << " agent_id=" << obj->printer_agent_id
+                                            << " connection_type=" << obj->connection_type()
+                                            << " online=" << obj->m_is_online;
                 }
 
                 //remove MachineObject from userMachineList
@@ -910,6 +968,9 @@ namespace Slic3r
                         iterat++;
                     }
                 }
+                BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: parse_user_print_info complete provider=" << provider
+                                        << " parsed_count=" << new_list.size()
+                                        << " stored_count=" << userMachineList.size();
             }
         }
         catch (std::exception& e)
@@ -926,10 +987,14 @@ namespace Slic3r
         unsigned int http_code;
         std::string body;
         int result = m_agent->get_user_print_info(&http_code, &body, provider);
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: get_user_print_info provider=" << provider
+                                << " result=" << result << " http_code=" << http_code
+                                << " body_bytes=" << body.size();
         if (result == 0)
         {
             // parse_user_print_info and on_machine_alive (SSDP for discovery) both mutate the same userMachineList map.
             // on_machine_alive mutates the map on the UI thread, do the same for parse_user_print_info.
+            BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: queueing parse_user_print_info on UI thread";
             Slic3r::GUI::wxGetApp().CallAfter([this, body]() { parse_user_print_info(body); });
         }
     }

src/slic3r/GUI/DeviceCore/DevManager.h

@@ -74,10 +74,9 @@ public:
     void erase_user_machine(std::string dev_id) { userMachineList.erase(dev_id); }
     void clean_user_info(bool keep_local_selection = false);
 
-    // target_agent_id: id of the agent being swapped to (empty = no agent-mismatch check,
-    // just the original "drop Other Devices" behavior). Pass the incoming agent's id, not the
-    // live one - this runs before the live agent is repointed.
-    void clear_other_devices(const std::string& target_agent_id = "");
+    // Retain agent-owned LAN discoveries across a switch; the active-agent list filter keeps
+    // entries from other agents hidden while allowing them to reappear when switched back.
+    void clear_other_devices();
 
     void load_last_machine();
     void update_user_machine_list_info(const std::string& provider);
@@ -154,4 +153,4 @@ public:
 protected:
     virtual void on_timer(wxTimerEvent& event);
 };
-};
+};

src/slic3r/GUI/DeviceManager.cpp

@@ -53,6 +53,7 @@
 #include "DeviceCore/DevStatus.h"
 #include "DeviceCore/DevUpgrade.h"
 
+#include "IPrinterAgent.hpp"
 
 #define CALI_DEBUG
 #define MINUTE_30 1800000    //ms
@@ -373,8 +374,22 @@ NozzleVolumeType convert_to_nozzle_type(const std::string &str)
 wxString MachineObject::get_printer_type_display_str() const
 {
     std::string display_name = DevPrinterConfigUtil::get_printer_display_name(printer_type);
+
+    // Bambu printers use m_resource_file_path + "/printers/" + type_str + ".json", which is a semantic that only works for their profiles.
+    // For any other profile, we can simply consult preset bundle if the model_id exists. 
+    if (display_name.empty()) {
+        for (const auto& [vendor_id, vendor] : GUI::wxGetApp().preset_bundle->vendors) {
+            for (const auto& model : vendor.models) {
+                if (printer_type == model.model_id)
+                    display_name = model.name;
+            }
+        }
+    }
+
     if (!display_name.empty())
         return display_name;
+    else if (printer_type == "orcasonar")
+        return "OrcaSonar Printer";
     else
         return _L("Unknown");
 }
@@ -1341,7 +1356,6 @@ int MachineObject::command_get_access_code() {
     return this->publish_json(j);
 }
 
-
 int MachineObject::command_request_push_all(bool request_now)
 {
     auto curr_time = std::chrono::system_clock::now();
@@ -1473,26 +1487,29 @@ int MachineObject::command_upgrade_module(std::string url, std::string module_ty
 
 int MachineObject::command_xyz_abs()
 {
-    return this->publish_gcode("G90 \n");
+    if (!m_agent) return -1;
+    int rtn = m_agent->command_xyz_abs(get_dev_id(), MachineObject::m_sequence_id++, is_lan_mode_printer());
+    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
+        show_unsupported_dlg(rtn);
+    return rtn;
 }
 
 int MachineObject::command_auto_leveling()
 {
-    return this->publish_gcode("G29 \n");
+    if (!m_agent) return -1;
+    int rtn = m_agent->command_auto_leveling(get_dev_id(), MachineObject::m_sequence_id++, is_lan_mode_printer());
+    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
+        show_unsupported_dlg(rtn);
+    return rtn;
 }
 
 int MachineObject::command_go_home()
 {
-    if (m_support_mqtt_homing)
-    {
-        json j;
-        j["print"]["command"] = "back_to_center";
-        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
-        return this->publish_json(j);
-    }
-
-    // gcode command
-    return this->is_in_printing() ? this->publish_gcode("G28 X\n") : this->publish_gcode("G28 \n");
+    if (!m_agent) return -1;
+    int rtn = m_agent->command_go_home(get_dev_id(), this->is_in_printing(), m_support_mqtt_homing, MachineObject::m_sequence_id++, is_lan_mode_printer());
+    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
+        show_unsupported_dlg(rtn);
+    return rtn;
 }
 
 int MachineObject::command_task_partskip(std::vector<int> part_ids)
@@ -1614,23 +1631,20 @@ int MachineObject::command_stop_buzzer()
 
 int MachineObject::command_set_bed(int temp)
 {
-    if (m_support_mqtt_bet_ctrl)
-    {
-        json j;
-        j["print"]["command"] = "set_bed_temp";
-        j["print"]["temp"] = temp;
-        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
-        return this->publish_json(j);
-    }
-
-    std::string gcode_str = (boost::format("M140 S%1%\n") % temp).str();
-    return this->publish_gcode(gcode_str);
+    if (!m_agent) return -1;
+    int rtn = m_agent->command_set_bed(get_dev_id(), temp, m_support_mqtt_bet_ctrl, MachineObject::m_sequence_id++, is_lan_mode_printer());
+    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
+        show_unsupported_dlg(rtn);
+    return rtn;
 }
 
 int MachineObject::command_set_nozzle(int temp)
 {
-    std::string gcode_str = (boost::format("M104 S%1%\n") % temp).str();
-    return this->publish_gcode(gcode_str);
+    if (!m_agent) return -1;
+    int rtn = m_agent->command_set_nozzle(get_dev_id(), temp, MachineObject::m_sequence_id++, is_lan_mode_printer());
+    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
+        show_unsupported_dlg(rtn);
+    return rtn;
 }
 
 int MachineObject::command_set_nozzle_new(int nozzle_id, int temp)
@@ -1735,9 +1749,11 @@ int MachineObject::command_ams_user_settings(bool start_read_opt, bool tray_read
 
 int MachineObject::command_ams_calibrate(int ams_id)
 {
-    std::string gcode_cmd = (boost::format("M620 C%1% \n") % ams_id).str();
-    BOOST_LOG_TRIVIAL(trace) << "ams_debug: gcode_cmd" << gcode_cmd;
-    return this->publish_gcode(gcode_cmd);
+    if (!m_agent) return -1;
+    int rtn = m_agent->command_ams_calibrate(get_dev_id(), ams_id, MachineObject::m_sequence_id++, is_lan_mode_printer());
+    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
+        show_unsupported_dlg(rtn);
+    return rtn;
 }
 
 int MachineObject::command_ams_filament_settings(int ams_id, int slot_id, std::string filament_id, std::string setting_id, std::string tray_color, std::string tray_type, int nozzle_temp_min, int nozzle_temp_max)
@@ -1775,9 +1791,11 @@ int MachineObject::command_ams_filament_settings(int ams_id, int slot_id, std::s
 
 int MachineObject::command_ams_refresh_rfid(std::string tray_id)
 {
-    std::string gcode_cmd = (boost::format("M620 R%1% \n") % tray_id).str();
-    BOOST_LOG_TRIVIAL(trace) << "ams_debug: gcode_cmd" << gcode_cmd;
-    return this->publish_gcode(gcode_cmd);
+    if (!m_agent) return -1;
+    int rtn = m_agent->command_ams_refresh_rfid(get_dev_id(), tray_id, MachineObject::m_sequence_id++, is_lan_mode_printer());
+    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
+        show_unsupported_dlg(rtn);
+    return rtn;
 }
 
 int MachineObject::command_ams_refresh_rfid2(int ams_id,  int slot_id)
@@ -1790,12 +1808,20 @@ int MachineObject::command_ams_refresh_rfid2(int ams_id,  int slot_id)
     return this->publish_json(j);
 }
 
+int MachineObject::command_start_camera()
+{
+    if (!m_agent) return -1;
+    return m_agent->command_start_camera(get_dev_id());
+}
+
 
 int MachineObject::command_ams_select_tray(std::string tray_id)
 {
-    std::string gcode_cmd = (boost::format("M620 P%1% \n") % tray_id).str();
-    BOOST_LOG_TRIVIAL(trace) << "ams_debug: gcode_cmd" << gcode_cmd;
-    return this->publish_gcode(gcode_cmd);
+    if (!m_agent) return -1;
+    int rtn = m_agent->command_ams_select_tray(get_dev_id(), tray_id, MachineObject::m_sequence_id++, is_lan_mode_printer());
+    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
+        show_unsupported_dlg(rtn);
+    return rtn;
 }
 
 int MachineObject::command_ams_control(std::string action)
@@ -1954,47 +1980,12 @@ int MachineObject::command_ams_air_print_detect(bool air_print_detect)
 
 int MachineObject::command_axis_control(std::string axis, double unit, double input_val, int speed)
 {
-    if (m_support_mqtt_axis_control)
-    {
-        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.compare("Y") == 0 || axis.compare("Z") == 0)) {
-            dir = -dir;
-        }
-
-        json j;
-        j["print"]["command"] = "xyz_ctrl";
-        j["print"]["axis"] = axis;
-        j["print"]["dir"] = dir;
-        j["print"]["mode"] = (std::abs(input_val) >= 10) ? 1 : 0;
-        j["print"]["sequence_id"] = std::to_string(MachineObject::m_sequence_id++);
-        return this->publish_json(j);
-    }
-
-    double value = input_val;
-    if (!is_core_xy()) {
-        if ( axis.compare("Y") == 0
-            || axis.compare("Z")  == 0) {
-            value = -1.0 * input_val;
-        }
-    }
-
-    char cmd[256];
-    if (axis.compare("X") == 0
-        || axis.compare("Y") == 0
-        || axis.compare("Z") == 0) {
-        sprintf(cmd, "M211 S \nM211 X1 Y1 Z1\nM1002 push_ref_mode\nG91 \nG1 %s%0.1f F%d\nM1002 pop_ref_mode\nM211 R\n", axis.c_str(), value * unit, speed);
-    }
-    else if (axis.compare("E") == 0) {
-        sprintf(cmd, "M83 \nG0 %s%0.1f F%d\n", axis.c_str(), value * unit, speed);
-    }
-    else {
-        return -1;
-    }
-
-
-    return this->publish_gcode(cmd);
+    if (!m_agent) return -1;
+    int rtn = m_agent->command_axis_control(get_dev_id(), axis, unit, input_val, speed, is_core_xy(),
+                                             m_support_mqtt_axis_control, MachineObject::m_sequence_id++, is_lan_mode_printer());
+    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE)
+        show_unsupported_dlg(rtn);
+    return rtn;
 }
 
 int MachineObject::command_extruder_control(int nozzle_id, double val)
@@ -2619,7 +2610,12 @@ void MachineObject::reset()
             vt_slot.erase(vt_slot.begin() + 1);
         }
     }
-    subtask_ = nullptr;
+    // why: reset reuses MachineObject, so release its lazy subtask
+    // before dropping the pointer to prevent reconnect leaks.
+    if (subtask_) {
+        delete subtask_;
+        subtask_ = nullptr;
+    }
     has_extra_flow_type = false;
     m_partskip_ids.clear();
 }
@@ -2629,10 +2625,24 @@ void MachineObject::set_print_state(std::string status)
     print_status = status;
 }
 
+// why: printer agents can report progress without BBL cloud task identity.
+void MachineObject::update_print_progress(const json& value)
+{
+    if (value.is_string())
+        mc_print_percent = stoi(value.get<std::string>());
+    else if (value.is_number_integer())
+        mc_print_percent = value.get<int>();
+    else
+        return;
+
+    if (BBLSubTask* curr_task = get_subtask())
+        curr_task->task_progress = mc_print_percent;
+}
+
 int MachineObject::connect(bool use_openssl)
 {
     if (get_dev_ip().empty()) return -1;
-    std::string username = "bblp";
+    std::string username = m_agent ? m_agent->default_lan_username() : std::string();
     std::string password = get_access_code();
 
     if (m_agent) {
@@ -2742,6 +2752,14 @@ int MachineObject::publish_json(const json& json_item, int qos, int flag)
         BOOST_LOG_TRIVIAL(error) << "publish_json: " << json_item.dump() << " code: " << rtn;
     }
 
+    // why: the agent is the only thing that knows what it can translate, so it reports
+    // not-supported in its return value and this - the single funnel every command_* builder
+    // passes through - is the one place that turns it into something the user sees. No list of
+    // unsupported commands is needed anywhere: an agent that has no case for a command says so.
+    if (rtn == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED || rtn == ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE) {
+        show_unsupported_dlg(rtn);
+    }
+
     return rtn;
 }
 
@@ -3046,6 +3064,13 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
             }
         } catch (...) {}
 
+        try {
+            if (j.contains("info"))
+                parse_new_info2(j["info"]);
+        } catch (...) {
+            BOOST_LOG_TRIVIAL(error) << "parse_json: failed to parse OrcaSonar capability info";
+        }
+
         try {
             if (auto ptr = m_fila_system->GetAmsFirmwareSwitch().lock()) {
                 ptr->ParseFirmwareSwitch(j);
@@ -3298,10 +3323,7 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                         print_type = jj["print_type"].get<std::string>();
                     }
                     if (jj.contains("mc_percent")) {
-                        if (jj["mc_percent"].is_string())
-                            mc_print_percent = stoi(j["print"]["mc_percent"].get<std::string>());
-                        else if (jj["mc_percent"].is_number_integer())
-                            mc_print_percent = j["print"]["mc_percent"].get<int>();
+                        update_print_progress(jj["mc_percent"]);
                     }
                     if (jj.contains("mc_print_sub_stage")) {
                         if (jj["mc_print_sub_stage"].is_number_integer())
@@ -3471,6 +3493,9 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                             this->task_id_ = jj["task_id"].get<std::string>();
                         }
 
+                        if (jj.contains("thumbnail_url") && jj["thumbnail_url"].is_string())
+                            m_agent_thumbnail_url = jj["thumbnail_url"].get<std::string>();
+
                         if (jj.contains("job_attr")) {
                             int jobAttr = jj["job_attr"].get<int>();
                             jobState_ =  get_flag_bits(jobAttr, 4, 4);
@@ -3516,7 +3541,6 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                         update_slice_info(jj["project_id"].get<std::string>(), jj["profile_id"].get<std::string>(), jj["subtask_id"].get<std::string>(), plate_index);
                         BBLSubTask* curr_task = get_subtask();
                         if (curr_task) {
-                            curr_task->task_progress = mc_print_percent;
                             curr_task->printing_status = print_status;
                             curr_task->task_id = jj["subtask_id"].get<std::string>();
                         }
@@ -3819,6 +3843,7 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                                         has_ipcam = true;
                                     } else {
                                         has_ipcam = false;
+                                        webcam_stream_url.clear();
                                     }
                                 }
                                 if (ipcam.contains("resolution")) {
@@ -3853,6 +3878,9 @@ int MachineObject::parse_json(std::string tunnel, std::string payload, bool key_
                                     liveview_local = local_rtsp_url.empty() ? LVL_None : local_rtsp_url == "disable"
                                             ? LVL_Disable : boost::algorithm::starts_with(local_rtsp_url, "rtsps") ? LVL_Rtsps : LVL_Rtsp;
                                 }
+                                if (ipcam.contains("stream_url") && ipcam["stream_url"].is_string()) {
+                                    webcam_stream_url = ipcam["stream_url"].get<std::string>();
+                                }
                                 if (ipcam.contains("tutk_server")) {
                                     tutk_state = ipcam["tutk_server"].get<std::string>();
                                 }
@@ -5432,6 +5460,86 @@ void MachineObject::parse_new_info(json print)
     }
 }
 
+void MachineObject::parse_new_info2(const json& info)
+{
+    if (!info.is_object() || info.value("command", "") != "get_capabilities")
+        return;
+
+    const auto capabilities_it = info.find("capabilities");
+    if (capabilities_it == info.end() || !capabilities_it->is_object())
+        return;
+    const auto flags_it = capabilities_it->find("flags");
+    if (flags_it == capabilities_it->end() || !flags_it->is_object())
+        return;
+
+    const json& flags = *flags_it;
+    BOOST_LOG_TRIVIAL(info) << "parse_new_info2: OrcaSonar capability flags=" << flags.dump();
+
+    auto parse_bool = [&flags](const char* name, bool& target) {
+        const auto it = flags.find(name);
+        if (it != flags.end() && it->is_boolean())
+            target = it->get<bool>();
+    };
+
+    parse_bool("support_send_to_sd", is_support_send_to_sdcard);
+    parse_bool("support_filament_backup", is_support_filament_backup);
+    parse_bool("support_update_remain", is_support_update_remain);
+    parse_bool("support_auto_recovery_step_loss", is_support_auto_recovery_step_loss);
+    parse_bool("support_ams_humidity", is_support_ams_humidity);
+    parse_bool("support_prompt_sound", is_support_prompt_sound);
+    parse_bool("support_filament_tangle_detect", is_support_filament_tangle_detect);
+    parse_bool("support_1080dpi", is_support_1080dpi);
+    parse_bool("support_cloud_print_only", is_support_cloud_print_only);
+    parse_bool("support_command_ams_switch", is_support_command_ams_switch);
+    parse_bool("support_mqtt_alive", is_support_mqtt_alive);
+    parse_bool("support_motor_noise_cali", is_support_motor_noise_cali);
+    parse_bool("support_timelapse", is_support_timelapse);
+    parse_bool("support_user_preset", is_support_user_preset);
+    parse_bool("support_refresh_nozzle", is_support_refresh_nozzle);
+    parse_bool("support_flow_calibration", is_support_flow_calibration);
+    parse_bool("support_build_plate_marker_detect", is_support_build_plate_marker_detect);
+    parse_bool("support_nozzle_blob_detect", is_support_nozzle_blob_detection);
+
+    if (!m_manager->IsMultiMachineEnabled() && !is_support_agora)
+        parse_bool("support_tunnel_mqtt", is_support_tunnel_mqtt);
+
+    const auto bed_leveling_it = flags.find("support_bed_leveling");
+    if (bed_leveling_it != flags.end() && bed_leveling_it->is_number_integer())
+        is_support_bed_leveling = bed_leveling_it->get<int>();
+
+    auto copy_bool = [&flags](json& target, const char* name) {
+        const auto it = flags.find(name);
+        if (it != flags.end() && it->is_boolean())
+            target[name] = *it;
+    };
+
+    // The capability manifest uses an object for this range, while the legacy
+    // DeviceCore parser consumes a boolean plus a two-element range array.
+    json device_config;
+    copy_bool(device_config, "support_chamber");
+    copy_bool(device_config, "support_first_layer_inspect");
+    copy_bool(device_config, "support_ai_monitoring");
+    copy_bool(device_config, "support_lidar_calibration");
+    const auto chamber_edit_it = flags.find("support_chamber_temp_edit");
+    if (chamber_edit_it != flags.end() && chamber_edit_it->is_boolean()) {
+        device_config["support_chamber_temp_edit"] = *chamber_edit_it;
+    } else if (chamber_edit_it != flags.end() && chamber_edit_it->is_object()) {
+        const auto min_it = chamber_edit_it->find("min");
+        const auto max_it = chamber_edit_it->find("max");
+        if (min_it != chamber_edit_it->end() && max_it != chamber_edit_it->end() && min_it->is_number() && max_it->is_number()) {
+            device_config["support_chamber_temp_edit"]       = true;
+            device_config["support_chamber_temp_edit_range"] = {*min_it, *max_it};
+        }
+    }
+
+    json fan_config;
+    copy_bool(fan_config, "support_aux_fan");
+    copy_bool(fan_config, "support_chamber_fan");
+
+    m_config->ParseConfig(device_config);
+    m_fan->ParseV2_0(fan_config);
+}
+
 static bool is_hex_digit(char c) {
     return std::isxdigit(static_cast<unsigned char>(c)) != 0;
 }

src/slic3r/GUI/DeviceManager.hpp

@@ -18,6 +18,7 @@
 #include "boost/bimap/bimap.hpp"
 #include "libslic3r/calib.hpp"
 #include "libslic3r/Utils.hpp"
+#include "slic3r/Utils/PrinterNetworkTypes.hpp"
 
 #include "DeviceCore/DevDefs.h"
 #include "DeviceCore/DevConfigUtil.h"
@@ -100,7 +101,6 @@ struct DevPrintTaskRatingInfo;
 // given nozzle diameter (mm), bucketed per nozzle size to mirror the printer firmware.
 bool is_stringing_prone_filament(const std::string& filament_id, float nozzle_diameter);
 
-
 class MachineObject
 {
 private:
@@ -547,30 +547,12 @@ public:
     bool xcam_first_layer_inspector { false };
     time_t  xcam_first_layer_hold_start = 0;
     std::string local_rtsp_url;
+    std::string webcam_stream_url;
     std::string tutk_state;
-    enum LiveviewLocal {
-        LVL_None,
-        LVL_Disable,
-        LVL_Local,
-        LVL_Rtsps,
-        LVL_Rtsp
-    } liveview_local{ LVL_None };
-    enum LiveviewRemote {
-        LVR_None,
-        LVR_Tutk,
-        LVR_Agora,
-        LVR_TutkAgora
-    } liveview_remote{ LVR_None };
-    enum FileLocal {
-        FL_None,
-        FL_Local
-    } file_local{ FL_None };
-    enum FileRemote {
-        FR_None,
-        FR_Tutk,
-        FR_Agora,
-        FR_TutkAgora
-    } file_remote{ FR_None };
+    LiveviewLocal liveview_local{ LiveviewLocal::LVL_None };
+    LiveviewRemote liveview_remote{ LiveviewRemote::LVR_None};
+    FileLocal file_local{ FileLocal::FL_None };
+    FileRemote file_remote{ FileRemote::FR_None };
 
     enum PlateMakerDectect : int
     {
@@ -708,6 +690,8 @@ public:
     std::string  subtask_id_;
     std::string  job_id_;
     std::string  last_subtask_id_;
+    // note: printer-agent-supplied thumbnail url, empty when the agent supplies none.
+    std::string  m_agent_thumbnail_url;
     BBLSliceInfo* slice_info {nullptr};
     boost::thread* get_slice_info_thread { nullptr };
     boost::thread* get_model_task_thread { nullptr };
@@ -765,6 +749,7 @@ public:
     int command_set_printer_nozzle(std::string nozzle_type, float diameter);
     int command_set_printer_nozzle2(int id, std::string nozzle_type, float diameter);
     int command_get_access_code();
+    int command_start_camera();
     int command_ack_proceed(json& proceed);
     int command_purification_disable();
     int command_dont_remind_next_time(json& mqtt_guard_json);
@@ -894,6 +879,7 @@ public:
     static bool is_in_printing_status(std::string status);
 
     void set_print_state(std::string status);
+    void update_print_progress(const json& value);
 
     bool is_connected();
     bool is_connecting();
@@ -961,6 +947,7 @@ public:
     /*for parse new info*/
     bool check_enable_np(const json& print) const;
     void parse_new_info(json print);
+    void parse_new_info2(const json& info);
     int  get_flag_bits(std::string str, int start, int count = 1) const;
     uint32_t get_flag_bits_no_border(std::string str, int start_idx, int count = 1) const;
     int get_flag_bits(int num, int start, int count = 1, int base = 10) const;

src/slic3r/GUI/GUI_App.cpp

@@ -3,6 +3,7 @@
 #include "libslic3r/Technologies.hpp"
 #include "libslic3r/Platform.hpp"
 #include "GUI_App.hpp"
+#include "DeviceCore/DevConfigUtil.h"
 #include "BindDialog.hpp"
 #include "DeviceManager.hpp"
 #include "HMS.hpp"
@@ -23,7 +24,6 @@
 #include <boost/locale/encoding_utf.hpp>
 #include <boost/log/detail/native_typeof.hpp>
 #include <libslic3r/Config.hpp>
-#include <mutex>
 #include <slic3r/plugin/PythonPluginInterface.hpp>
 #include <wx/event.h>
 
@@ -40,9 +40,11 @@
 #include <iterator>
 #include <exception>
 #include <cstdlib>
+#include <mutex>
 #include <regex>
 #include <thread>
 #include <string_view>
+
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/algorithm/string.hpp>
 #include <boost/format.hpp>
@@ -87,7 +89,6 @@
 #include "libslic3r/Thread.hpp"
 #include "libslic3r/miniz_extension.hpp"
 #include "libslic3r/Utils.hpp"
-#include "libslic3r/Color.hpp"
 #include "slic3r/plugin/PluginManager.hpp"
 #include "slic3r/plugin/host/PluginHostUi.hpp"
 #include "slic3r/plugin/PythonInterpreter.hpp"
@@ -107,19 +108,18 @@
 #include "../Utils/PrintHost.hpp"
 #include "../Utils/Process.hpp"
 #include "../Utils/wxInspectorPlugins/Registration.hpp"
-#include "../Utils/MacDarkMode.hpp"
 #include "../Utils/Http.hpp"
 #include "../Utils/InstanceID.hpp"
 #include "../Utils/UndoRedo.hpp"
 #include "slic3r/Config/Snapshot.hpp"
 #include "Preferences.hpp"
 #include "Tab.hpp"
-#include "SysInfoDialog.hpp"
 #include "UpdateDialogs.hpp"
 #include "Mouse3DController.hpp"
 #include "RemovableDriveManager.hpp"
 #include "InstanceCheck.hpp"
 #ifdef __APPLE__
+#include "../Utils/MacDarkMode.hpp"
 #include "DeepLinkHandlerMac.h"
 #endif
 #include "NotificationManager.hpp"
@@ -128,8 +128,6 @@
 #include "PrintHostDialogs.hpp"
 #include "NetworkPluginDialog.hpp"
 #include "DesktopIntegrationDialog.hpp"
-#include "SendSystemInfoDialog.hpp"
-#include "ParamsDialog.hpp"
 #include "KBShortcutsDialog.hpp"
 #include "DownloadProgressDialog.hpp"
 #include "TroubleshootDialog.hpp"
@@ -140,7 +138,6 @@
 #include "Widgets/ProgressDialog.hpp"
 
 //BBS: DailyTip and UserGuide Dialog
-#include "WebDownPluginDlg.hpp"
 #include "WebGuideDialog.hpp"
 #include "ReleaseNote.hpp"
 #include "PrivacyUpdateDialog.hpp"
@@ -2385,14 +2382,8 @@ bool GUI_App::is_blocking_printing(MachineObject *obj_)
 {
     DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
     if (!dev) return true;
-    std::string target_model;
     if (obj_ == nullptr) {
         obj_ = dev->get_selected_machine();
-        if (obj_) {
-            target_model = obj_->printer_type;
-        }
-    } else {
-        target_model = obj_->printer_type;
     }
 
     if (!obj_)
@@ -2403,14 +2394,7 @@ bool GUI_App::is_blocking_printing(MachineObject *obj_)
     PresetBundle *preset_bundle = wxGetApp().preset_bundle;
     std::string    source_model  = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
 
-    if (source_model != target_model) {
-        std::vector<std::string>      compatible_machine = obj_->get_compatible_machine();
-        vector<std::string>::iterator it                 = find(compatible_machine.begin(), compatible_machine.end(), source_model);
-        if (it == compatible_machine.end()) {
-            return true;
-        }
-    }
-    return false;
+    return !DevPrinterConfigUtil::is_printer_model_compatible(source_model, *obj_);
 }
 
 // If formatted for github, plaintext with OpenGL extensions enclosed into <details>.
@@ -3961,20 +3945,16 @@ void GUI_App::set_live_printer_agent(std::shared_ptr<IPrinterAgent> agent)
         m_agent->set_user_selected_machine("");
         // note: belt-and-suspenders (precedent: DeviceManagerRefresher::on_timer)
         dev->OnSelectedMachineLost(); // why: clear stale sidebar sync-status / AMS
-        // why: drop stale LAN discoveries; keep My Devices, but only those belonging to the
-        // agent we're about to swap to, so a device stamped by the outgoing agent doesn't
-        // linger hidden - the new agent's start_discovery re-inserts and re-stamps it fresh.
-        // agent is null when clearing the live agent entirely (e.g. plugin unload); there's no
-        // target to filter against then, so fall back to the original "keep all My Devices"
-        // behavior rather than guessing.
-        dev->clear_other_devices(agent ? agent->get_agent_info().id : std::string());
+        // why: retain agent-owned LAN discoveries so agents without automatic discovery (for
+        // example the Moonraker-based Qidi/Snapmaker agents) can reuse them after a switch.
+        dev->clear_other_devices();
     }
 
     m_agent->set_printer_agent(agent);
     sidebar().update_all_preset_comboboxes();
 }
 
-std::string GUI_App::resolve_printer_agent_id(const std::string& stored_id)
+std::string GUI_App::resolve_printer_agent_id(const std::string& stored_id) const
 {
     if (!stored_id.empty())
         return stored_id;
@@ -4010,6 +3990,7 @@ void GUI_App::switch_printer_agent()
 
     std::string log_dir        = data_dir();
     std::string cloud_agent_id = agent_info.id == BBL_PRINTER_AGENT_ID ? BBL_CLOUD_PROVIDER : ORCA_CLOUD_PROVIDER;
+    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " " << agent_info.id;
     std::shared_ptr<ICloudServiceAgent> cloud_agent = m_agent->get_cloud_agent(cloud_agent_id);
 
     // Create new printer agent via registry
@@ -4023,8 +4004,10 @@ void GUI_App::switch_printer_agent()
         return;
     }
 
-    // The factory caches agents per ID, so an identical pointer means the agent type is unchanged.
-    if (m_agent->get_printer_agent() == new_printer_agent) {
+    // Compare the registered IDs, not only the implementation pointer. Different registry IDs
+    // may intentionally be backed by the same implementation object (especially for plugins).
+    const auto current_printer_agent = m_agent->get_printer_agent();
+    if (current_printer_agent && current_printer_agent->get_agent_info().id == effective_agent_id) {
         // Orca: the agent type is unchanged (e.g. switching between two Moonraker/Klipper
         // printer presets), so the selected machine and the agent's cached device_info still
         // point at the previously active printer preset. Re-select the machine when the new
@@ -4983,14 +4966,16 @@ bool GUI_App::is_user_login(const std::string& provider/* = ORCA_CLOUD_PROVIDER*
     return false;
 }
 
-const std::string& GUI_App::get_printer_cloud_provider() const
+std::string GUI_App::get_printer_cloud_provider() const
 {
-    // Orca todo: this need to be revisted. currently it is mainly used for device manager and related clausses and only bambu machines use them.
-    // 
-    return BBL_CLOUD_PROVIDER;
+    const std::string agent_id = resolve_printer_agent_id(
+        preset_bundle ? preset_bundle->printers.get_edited_preset().config.opt_string("printer_agent")
+                      : std::string());
+    return agent_id == BBL_PRINTER_AGENT_ID ? BBL_CLOUD_PROVIDER : ORCA_CLOUD_PROVIDER;
 }
 
 
+
 bool GUI_App::check_login(const std::string& provider/* = ORCA_CLOUD_PROVIDER*/)
 {
     bool result = false;

src/slic3r/GUI/GUI_App.hpp

@@ -23,9 +23,6 @@
 #include <wx/snglinst.h>
 #include <wx/msgdlg.h>
 
-#include <mutex>
-#include <stack>
-
 //#define BBL_HAS_FIRST_PAGE          1
 #define STUDIO_INACTIVE_TIMEOUT     15*60*1000
 #define LOG_FILES_MAX_NUM           30
@@ -369,7 +366,7 @@ public:
     // Reconcile the live printer agent with the stored preset selection.
     void switch_printer_agent();
 
-    std::string resolve_printer_agent_id(const std::string& stored_id);
+    std::string resolve_printer_agent_id(const std::string& stored_id) const;
     // ORCA TODO: in the future, bbl presets should specify "bbl" printer agent id
     // then, all resolve and canonical would just be ORCA<->""
     std::string canonical_printer_agent_id(const std::string& picked_id);
@@ -495,7 +492,7 @@ public:
     bool            check_login(const std::string& provider = ORCA_CLOUD_PROVIDER);
     void            get_login_info(const std::string& provider = ORCA_CLOUD_PROVIDER);
     bool            is_user_login(const std::string& provider = ORCA_CLOUD_PROVIDER);
-    const std::string& get_printer_cloud_provider() const;
+    std::string      get_printer_cloud_provider() const;
 
     void            request_user_login(int online_login = 0, const std::string& provider = ORCA_CLOUD_PROVIDER);
     void            request_user_handle(int online_login = 0, const std::string& provider = ORCA_CLOUD_PROVIDER);

src/slic3r/GUI/IMediaController.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <wx/mediactrl.h>
+#include <wx/uri.h>
+
+#include <memory>
+
+#include <slic3r/Utils/IPrinterAgent.hpp>
+
+namespace Slic3r { namespace GUI {
+
+class IMediaController
+{
+public:
+    virtual ~IMediaController() = default;
+
+    virtual void Load(wxURI url) = 0;
+
+    // The default keeps existing media controllers unaware of camera-specific modes.
+    virtual void Load(wxURI url, CameraStreamMode mode)
+    {
+        (void) mode;
+        Load(url);
+    }
+
+    virtual void Play() = 0;
+
+    virtual void Stop() = 0;
+
+    virtual wxMediaState GetState() { return wxMediaState{}; }
+
+    virtual int GetLastError() const { return {}; };
+
+    virtual wxSize GetVideoSize() const { return {}; };
+
+    virtual void StartSession(std::unique_ptr<ICameraSignalingChannel> channel)
+    {
+        (void) channel;
+    }
+
+    virtual void StopSession() {}
+
+private:
+};
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/Jobs/PrintJob.cpp

@@ -14,6 +14,7 @@
 
 #include "slic3r/Utils/FileTransferUtils.hpp"
 #include "slic3r/Utils/BBLNetworkPlugin.hpp"
+#include "NetworkAgent.hpp"
 
 namespace Slic3r {
 namespace GUI {
@@ -203,7 +204,7 @@ void PrintJob::process(Ctl &ctl)
     params.dev_ip = m_dev_ip;
     params.use_ssl_for_ftp  = m_local_use_ssl_for_ftp;
     params.use_ssl_for_mqtt  = m_local_use_ssl;
-    params.username = "bblp";
+    params.username = m_agent->default_lan_username();
     params.password = m_access_code;
 
     // check access code and ip address

src/slic3r/GUI/Jobs/SendJob.cpp

@@ -126,7 +126,7 @@ void SendJob::process(Ctl &ctl)
     if (m_is_check_mode) {
         PrintParams verify_params;
         verify_params.dev_ip           = m_dev_ip;
-        verify_params.username         = "bblp";
+        verify_params.username         = agent->default_lan_username();
         verify_params.password         = m_access_code;
         verify_params.use_ssl_for_ftp  = m_local_use_ssl_for_ftp;
         verify_params.use_ssl_for_mqtt = m_local_use_ssl;
@@ -211,7 +211,7 @@ void SendJob::process(Ctl &ctl)
 
     // local print access
     params.dev_ip = m_dev_ip;
-    params.username = "bblp";
+    params.username = agent->default_lan_username();
     params.password = m_access_code;
     params.use_ssl_for_ftp = m_local_use_ssl_for_ftp;
     params.use_ssl_for_mqtt = m_local_use_ssl;

src/slic3r/GUI/MainFrame.cpp

@@ -4311,7 +4311,7 @@ void MainFrame::load_printer_url()
         if (auto *device_manager = wxGetApp().getDeviceManager()) {
             auto *machine = device_manager->get_selected_machine();
             if (!machine) {
-                auto machines = device_manager->get_my_machine_list();
+                auto machines = device_manager->get_my_machine_list(device_manager->get_current_printer_agent_id());
                 if (machines.size() == 1)
                     machine = machines.begin()->second;
             }

src/slic3r/GUI/MediaPlayCtrl.cpp

@@ -7,6 +7,7 @@
 #include "DeviceManager.hpp"
 #include "DeviceCore/DevConfigUtil.h"
 #include "slic3r/Utils/NetworkAgent.hpp"
+#include "slic3r/Utils/NetworkAgentFactory.hpp"
 #include "libslic3r/Thread.hpp"
 #include "libslic3r/AppConfig.hpp"
 #include "I18N.hpp"
@@ -15,11 +16,14 @@
 #include "slic3r/Utils/BBLNetworkPlugin.hpp"
 
 
+#include <algorithm>
+
 #include <boost/lexical_cast.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/nowide/cstdio.hpp>
 #include <boost/nowide/fstream.hpp>
 #include <boost/nowide/utf8_codecvt.hpp>
+#include <slic3r/GUI/DeviceManager.hpp>
 #undef pid_t
 #include <boost/process.hpp>
 #ifdef __WIN32__
@@ -139,6 +143,11 @@ MediaPlayCtrl::MediaPlayCtrl(wxWindow *parent, wxMediaCtrl3 *media_ctrl, const w
 
 MediaPlayCtrl::~MediaPlayCtrl()
 {
+    m_webrtc_stopping = true;
+    if (m_webrtc_ctrl)
+        m_webrtc_ctrl->StopSession();
+    m_media_ctrl->EndExternalStream();
+    m_webrtc_stopping = false;
     {
         boost::unique_lock lock(m_mutex);
         m_tasks.push_back("<exit>");
@@ -151,8 +160,77 @@ MediaPlayCtrl::~MediaPlayCtrl()
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": " << this;
 }
 
+void MediaPlayCtrl::SetWebMediaController(IMediaController *ctrl)
+{
+    m_web_ctrl = ctrl;
+}
+
+CameraStreamMode MediaPlayCtrl::current_mode() const
+{
+    auto agent = wxGetApp().getAgent();
+    return agent ? agent->get_camera_stream_mode() : CameraStreamMode::none;
+}
+
 void MediaPlayCtrl::SetMachineObject(MachineObject* obj)
 {
+    const CameraStreamMode mode = current_mode();
+    if (mode != m_last_mode) {
+        if (m_last_state != MEDIASTATE_IDLE) {
+            m_failed_code = 0; // a mode switch is not a stream failure - don't arm back-off
+            Stop(" ");
+        }
+        m_last_mode = mode;
+    }
+
+    switch (mode) {
+    case CameraStreamMode::http:
+    case CameraStreamMode::https:
+    case CameraStreamMode::http_snapshot:
+    case CameraStreamMode::rtsp: {
+        std::string machine = obj ? obj->get_dev_id() : "";
+        auto agent = wxGetApp().getAgent();
+        std::string url = agent ? agent->get_local_camera_stream_url() : "";
+        m_camera_exists = !url.empty();
+        Enable(obj && m_camera_exists);
+        bool changed = machine != m_machine || url != m_agent_camera_url;
+        m_machine   = machine;
+        m_agent_camera_url = url;
+        m_url       = from_u8(url);
+        if (!changed) {
+            return;
+        }
+        // A genuine machine/URL switch: not a failure, so drop any pending
+        // failure back-off before (re)starting on the new target.
+        m_web_user_stopped = false;
+        m_failed_code  = 0;
+        m_failed_retry = 0;
+        m_next_retry   = wxDateTime();
+        if (m_last_state != MEDIASTATE_IDLE)
+            Stop(" ");
+        return;
+    }
+    case CameraStreamMode::webrtc: {
+        std::string machine = obj ? obj->get_dev_id() : "";
+        m_camera_exists = obj != nullptr;
+        Enable(obj != nullptr);
+        const bool changed = machine != m_machine;
+        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::SetMachineObject webrtc: changed=" << changed
+                                << " last_state=" << m_last_state << " web_user_stopped=" << m_web_user_stopped;
+        m_machine = machine;
+        m_url.clear();
+        m_agent_camera_url.clear();
+        if (!changed) {
+            return;
+        }
+        m_web_user_stopped = false;
+        if (m_last_state != MEDIASTATE_IDLE)
+            Stop(" ");
+        return;
+    }
+    default:
+        break;
+    }
+
     std::string machine = obj ? obj->get_dev_id() : "";
     if (obj) {
         m_camera_exists  = obj->has_ipcam;
@@ -167,12 +245,12 @@ void MediaPlayCtrl::SetMachineObject(MachineObject* obj)
 
         if (DevPrinterConfigUtil::get_printer_series_str(obj->printer_type) == "series_o" && BBLNetworkPlugin::instance().use_legacy_network()) {
             // Legacy plugin cannot support remote play for H2D, force using local mode
-            m_remote_proto = MachineObject::LVR_None;
+            m_remote_proto = LiveviewRemote::LVR_None;
         }
     } else {
         m_camera_exists = false;
         m_lan_mode = false;
-        m_lan_proto = MachineObject::LVL_None;
+        m_lan_proto = LiveviewLocal::LVL_None;
         m_lan_ip.clear();
         m_lan_passwd.clear();
         m_dev_ver.clear();
@@ -182,8 +260,6 @@ void MediaPlayCtrl::SetMachineObject(MachineObject* obj)
     }
     Enable(obj && obj->is_info_ready() && obj->m_push_count > 0);
     if (machine == m_machine) {
-        if (m_last_state == MEDIASTATE_IDLE && IsEnabled())
-            Play();
         return;
     }
     m_machine = machine;
@@ -254,6 +330,90 @@ void refresh_agora_url(char const* device, char const* dev_ver, char const* chan
 
 void MediaPlayCtrl::Play()
 {
+    switch (current_mode()) {
+    case CameraStreamMode::http_snapshot:
+        if (!m_next_retry.IsValid() || wxDateTime::Now() < m_next_retry)
+            return;
+        if (!IsShownOnScreen()) return;
+        if (m_last_state != MEDIASTATE_IDLE) return;
+        if (m_machine.empty() || !IsEnabled() || !m_camera_exists || m_url.IsEmpty() || !m_web_ctrl) {
+            Stop(_L("Please confirm if the printer is connected."));
+            return;
+        }
+        m_button_play->SetIcon("media_stop");
+        m_web_ctrl->Load(wxURI(m_url), current_mode());
+        m_web_ctrl->Play();
+        m_last_state = wxMEDIASTATE_PLAYING;
+        SetStatus(_L("Playing..."), false);
+        return;
+    case CameraStreamMode::http:
+    case CameraStreamMode::https:
+    case CameraStreamMode::rtsp:
+        if (m_next_retry.IsValid() && wxDateTime::Now() < m_next_retry)
+            return;
+        if (!IsShownOnScreen()) return;
+        if (m_last_state != MEDIASTATE_IDLE) return;
+        m_failed_code = 0;
+        if (m_machine.empty() || !IsEnabled() || !m_camera_exists || m_url.IsEmpty()) {
+            Stop(_L("Please confirm if the printer is connected."));
+            return;
+        }
+        m_button_play->SetIcon("media_stop");
+        load();
+        return;
+    case CameraStreamMode::webrtc: {
+        BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::Play webrtc: last_state=" << m_last_state
+                                << " next_retry_valid=" << m_next_retry.IsValid()
+                                << " next_retry_future=" << (m_next_retry.IsValid() && wxDateTime::Now() < m_next_retry)
+                                << " failed_retry=" << m_failed_retry << " shown=" << IsShownOnScreen();
+        if (m_webrtc_ctrl && m_webrtc_ctrl->is_active()) {
+            BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::Play webrtc: session already active, ignoring";
+            return;
+        }
+        if (m_next_retry.IsValid() && wxDateTime::Now() < m_next_retry)
+            return;
+        if (!IsShownOnScreen() || m_last_state != MEDIASTATE_IDLE)
+            return;
+        m_failed_code = 0;
+        if (m_machine.empty() || !IsEnabled() || !m_camera_exists) {
+            Stop(_L("Please confirm if the printer is connected."));
+            return;
+        }
+        auto agent = wxGetApp().getAgent();
+        auto channel = agent ? agent->create_camera_signaling_channel(m_machine) : nullptr;
+        if (!channel) {
+            Stop(_L("Sign in to OrcaCloud to view the camera."));
+            return;
+        }
+        if (!m_webrtc_ctrl) {
+            m_webrtc_ctrl = std::make_unique<WebRtcMediaController>(
+                [this](const wxImage& image, wxSize size) { m_media_ctrl->SetExternalFrame(image, size); },
+                [this, token = std::weak_ptr<int>(m_token)](WebRtcMediaController::Status status) {
+                    if (token.expired())
+                        return;
+                    CallAfter([this, status] { on_webrtc_status(status); });
+                });
+        }
+        m_button_play->SetIcon("media_stop");
+        m_media_ctrl->BeginExternalStream();
+        m_last_state = MEDIASTATE_INITIALIZING;
+        SetStatus(_L("Initializing..."), false);
+        m_webrtc_stopping = false;
+        m_webrtc_ctrl->StartSession(std::move(channel));
+        m_webrtc_epoch = m_webrtc_ctrl->epoch();
+        return;
+    }
+    default: // assumed to be CameraStreamMode::none
+        if (NetworkAgent* agent = wxGetApp().getAgent()) {
+            if (auto printer_agent = agent->get_printer_agent()) {
+                if (printer_agent->get_agent_info().id != BBL_PRINTER_AGENT_ID) {
+                    return;
+                }
+            }
+        }
+        break;
+    }
+
     if (!m_next_retry.IsValid() || wxDateTime::Now() < m_next_retry)
         return;
     if (!IsShownOnScreen())
@@ -283,14 +443,14 @@ void MediaPlayCtrl::Play()
     BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::Play: " << m_lan_proto << m_remote_proto << m_disable_lan;
     NetworkAgent *agent = wxGetApp().getAgent();
     std::string  agent_version = agent ? agent->get_version() : "";
-    if (m_lan_proto > MachineObject::LVL_Disable && (m_lan_mode || !m_remote_proto) && !m_disable_lan && !m_lan_ip.empty()) {
+    if (m_lan_proto > LiveviewLocal::LVL_Disable && (m_lan_mode || !m_remote_proto) && !m_disable_lan && !m_lan_ip.empty()) {
         m_disable_lan = m_remote_proto && !m_lan_mode; // try remote next time
         std::string url;
-        if (m_lan_proto == MachineObject::LVL_Local)
+        if (m_lan_proto == LiveviewLocal::LVL_Local)
             url = "bambu:///local/" + m_lan_ip + ".?port=6000&user=" + m_lan_user + "&passwd=" + m_lan_passwd;
-        else if (m_lan_proto == MachineObject::LVL_Rtsps)
+        else if (m_lan_proto == LiveviewLocal::LVL_Rtsps)
             url = "bambu:///rtsps___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsps";
-        else if (m_lan_proto == MachineObject::LVL_Rtsp)
+        else if (m_lan_proto == LiveviewLocal::LVL_Rtsp)
             url = "bambu:///rtsp___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsp";
         url += "&device=" + m_machine;
         url += "&net_ver=" + agent_version;
@@ -312,8 +472,8 @@ void MediaPlayCtrl::Play()
     // !m_lan_mode && !m_remote_proto && m_lan_proto == LVL_Disable (*)
     // !m_lan_mode && !m_remote_proto && m_lan_proto == LVL_None (x)
 
-    if (m_lan_proto <= MachineObject::LVL_Disable && (m_lan_mode || !m_remote_proto)) {
-        Stop(m_lan_proto == MachineObject::LVL_None
+    if (m_lan_proto <= LiveviewLocal::LVL_Disable && (m_lan_mode || !m_remote_proto)) {
+        Stop(m_lan_proto == LiveviewLocal::LVL_None
             ? _L("A problem occurred. Please update the printer firmware and try again.")
             : _L("LAN Only Liveview is off. Please turn on the liveview on printer screen."));
         return;
@@ -381,8 +541,70 @@ void MediaPlayCtrl::Play()
 
 void start_ping_test();
 
+void MediaPlayCtrl::StopWebStream()
+{
+    if (m_last_state == MEDIASTATE_IDLE)
+        return;
+    if (m_web_ctrl)
+        m_web_ctrl->Stop();
+    m_button_play->SetIcon("media_play");
+    m_last_state = MEDIASTATE_IDLE;
+    SetStatus(_L("Video Stopped."), false);
+}
+
 void MediaPlayCtrl::Stop(wxString const &msg, wxString const &msg2)
 {
+    const bool webrtc_active = m_webrtc_ctrl && m_last_mode == CameraStreamMode::webrtc;
+    BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::Stop: last_state=" << m_last_state
+                            << " webrtc_active=" << webrtc_active << " failed_code=" << m_failed_code
+                            << " msg='" << msg.ToUTF8().data() << "'";
+    if (webrtc_active) {
+        m_webrtc_stopping = true;
+        m_webrtc_ctrl->StopSession();
+        m_media_ctrl->EndExternalStream();
+        m_webrtc_stopping = false;
+    }
+    switch (m_last_mode) {
+    case CameraStreamMode::http:
+    case CameraStreamMode::https:
+    case CameraStreamMode::http_snapshot: {
+        const bool snapshot = m_last_mode == CameraStreamMode::http_snapshot;
+        if (m_last_state != MEDIASTATE_IDLE) {
+            if (snapshot) {
+                if (m_web_ctrl) m_web_ctrl->Stop();
+            } else {
+                // http/https mode plays through the ffmpeg backend (m_media_ctrl), not
+                // the webview - tear its read thread down too, otherwise it keeps
+                // pulling and painting frames after the UI says "Video Stopped".
+                boost::unique_lock lock(m_mutex);
+                m_tasks.push_back("<stop>");
+                m_cond.notify_all();
+            }
+            m_button_play->SetIcon("media_play");
+            m_last_state = MEDIASTATE_IDLE;
+            if (!msg.IsEmpty())
+                SetStatus(msg);
+            else
+                SetStatus(_L("Video Stopped."), false);
+            // Keep retries bounded for an explicit or retry-driven playback attempt.
+            // m_failed_retry is cleared on success (onStateChanged) and on a deliberate
+            // machine switch (SetMachineObject); manual playback via TogglePlay resets it.
+            if (m_failed_code != 0) {
+                const bool auto_retry = wxGetApp().app_config->get("liveview", "auto_retry") != "false";
+                ++m_failed_retry;
+                m_next_retry = auto_retry
+                    ? wxDateTime::Now() + wxTimeSpan::Seconds(std::min(5 * m_failed_retry, 30))
+                    : wxDateTime::Now() + wxTimeSpan::Days(1); // "off": wait for a manual retry
+            }
+        } else if (!msg.IsEmpty()) {
+            SetStatus(msg, false);
+        }
+        return;
+    }
+    default:
+        break;
+    }
+
     int last_state = m_last_state;
 
     if (m_last_state != MEDIASTATE_IDLE) {
@@ -454,15 +676,38 @@ void MediaPlayCtrl::Stop(wxString const &msg, wxString const &msg2)
         m_next_retry = wxDateTime::Now() + wxTimeSpan::Seconds(5 * m_failed_retry);
 }
 
+void MediaPlayCtrl::on_webrtc_status(WebRtcMediaController::Status status)
+{
+    // Drop CallAfter-queued events from a superseded StartSession attempt.
+    if (status.epoch != m_webrtc_epoch)
+        return;
+    if (status.kind == WebRtcMediaController::Status::Connecting) {
+        m_last_state = MEDIASTATE_INITIALIZING;
+        SetStatus(_L("Initializing..."), false);
+    } else if (status.kind == WebRtcMediaController::Status::Playing) {
+        m_last_state = wxMEDIASTATE_PLAYING;
+        m_failed_code = 0;
+        m_failed_retry = 0;
+        SetStatus(_L("Playing..."), false);
+    } else if (status.kind == WebRtcMediaController::Status::Failed) {
+        m_failed_code = static_cast<int>(status.code) + 1;
+        Stop();
+    }
+    // Status::Stopped needs no action: a genuine failure arrives as Failed, and
+    // a stop we initiated is already handled by Stop() itself.
+}
+
 void MediaPlayCtrl::TogglePlay()
 {
     BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl::TogglePlay";
     if (m_last_state != MEDIASTATE_IDLE) {
         m_next_retry = wxDateTime();
+        m_web_user_stopped = true;
         Stop();
     } else {
         m_failed_retry = 0;
         m_user_triggered = true;
+        m_web_user_stopped = false;
         if (m_last_user_play + wxTimeSpan::Minutes(5) < wxDateTime::Now()) {
             m_last_failed_codes.clear();
             m_last_user_play = wxDateTime::Now();
@@ -528,13 +773,13 @@ void MediaPlayCtrl::ToggleStream()
             wxGetApp().app_config->set("not_show_vcamera_stop_prev", "1");
         if (res == wxID_CANCEL) return;
     }
-    if (m_lan_proto > MachineObject::LVL_Disable && (m_lan_mode || !m_remote_proto) && !m_disable_lan && !m_lan_ip.empty()) {
+    if (m_lan_proto > LiveviewLocal::LVL_Disable && (m_lan_mode || !m_remote_proto) && !m_disable_lan && !m_lan_ip.empty()) {
         std::string url;
-        if (m_lan_proto == MachineObject::LVL_Local)
+        if (m_lan_proto == LiveviewLocal::LVL_Local)
             url = "bambu:///local/" + m_lan_ip + ".?port=6000&user=" + m_lan_user + "&passwd=" + m_lan_passwd;
-        else if (m_lan_proto == MachineObject::LVL_Rtsps)
+        else if (m_lan_proto == LiveviewLocal::LVL_Rtsps)
             url = "bambu:///rtsps___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsps";
-        else if (m_lan_proto == MachineObject::LVL_Rtsp)
+        else if (m_lan_proto == LiveviewLocal::LVL_Rtsp)
             url = "bambu:///rtsp___" + m_lan_user + ":" + m_lan_passwd + "@" + m_lan_ip + "/streaming/live/1?proto=rtsp";
         url += "&device=" + into_u8(m_machine);
         url += "&dev_ver=" + m_dev_ver;
@@ -666,7 +911,8 @@ void MediaPlayCtrl::load()
 {
     m_last_state = MEDIASTATE_LOADING;
     SetStatus(_L("Loading..."));
-    if (wxGetApp().app_config->get("internal_developer_mode") == "true") {
+    const auto mode = current_mode();
+    if (mode == CameraStreamMode::none && wxGetApp().app_config->get("internal_developer_mode") == "true") {
         std::string file_h264 = data_dir() + "/video.h264";
         std::string file_info = data_dir() + "/video.info";
         BOOST_LOG_TRIVIAL(info) << "MediaPlayCtrl dump video to " << file_h264;
@@ -686,9 +932,8 @@ void MediaPlayCtrl::on_show_hide(wxShowEvent &evt)
     evt.Skip();
     if (m_isBeingDeleted) return;
     m_failed_retry = 0;
-    if (m_next_retry.IsValid()) // Try open 2 seconds later, to avoid quick play/stop
-        m_next_retry = wxDateTime::Now() + wxTimeSpan::Seconds(2);
-    IsShownOnScreen() ? Play() : Stop();
+    if (!IsShownOnScreen())
+        Stop();
 }
 
 void MediaPlayCtrl::media_proc()

src/slic3r/GUI/MediaPlayCtrl.h

@@ -9,6 +9,9 @@
 #define MediaPlayCtrl_h
 
 #include "wxMediaCtrl3.h"
+#include "IMediaController.hpp"
+#include "WebRtcMediaController.hpp"
+#include "slic3r/Utils/IPrinterAgent.hpp"
 
 #include <wx/panel.h>
 
@@ -36,6 +39,10 @@ public:
 
     void SetMachineObject(MachineObject * obj);
 
+    void SetWebMediaController(IMediaController *ctrl);
+
+    void StopWebStream();
+
     bool IsStreaming() const;
 
     void ToggleStream();
@@ -54,6 +61,7 @@ protected:
     void TogglePlay();
 
     void SetStatus(wxString const &msg, bool hyperlink = true);
+    void on_webrtc_status(WebRtcMediaController::Status status);
 
 private:
     void load();
@@ -66,6 +74,8 @@ private:
 
     static bool get_stream_url(std::string *url = nullptr);
 
+    CameraStreamMode current_mode() const;
+
 private:
     static inline const wxMediaState MEDIASTATE_IDLE = static_cast<wxMediaState>(3);
     static inline const wxMediaState MEDIASTATE_INITIALIZING = static_cast<wxMediaState>(4);
@@ -76,6 +86,13 @@ private:
     std::shared_ptr<int> m_token = std::make_shared<int>(0);
 
     wxMediaCtrl3 * m_media_ctrl;
+    IMediaController * m_web_ctrl = nullptr;
+    std::unique_ptr<WebRtcMediaController> m_webrtc_ctrl;
+    CameraStreamMode m_last_mode = CameraStreamMode::none;
+    bool m_webrtc_stopping = false;
+    std::uint64_t m_webrtc_epoch = 0;
+    std::string m_agent_camera_url;
+    bool m_web_user_stopped = false;
     wxMediaState m_last_state = MEDIASTATE_IDLE;
     std::string m_machine;
     int m_lan_proto = 0;

src/slic3r/GUI/Monitor.cpp

@@ -34,6 +34,8 @@
 
 #include "DeviceCore/DevManager.h"
 
+#include <boost/log/trivial.hpp>
+
 namespace Slic3r {
 namespace GUI {
 
@@ -259,6 +261,7 @@ void MonitorPanel::msw_rescale()
 
 void MonitorPanel::select_machine(std::string machine_sn)
 {
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MonitorPanel::select_machine queueing machine_sn=" << machine_sn;
     wxCommandEvent *event = new wxCommandEvent(wxEVT_COMMAND_CHOICE_SELECTED);
     event->SetString(machine_sn);
     wxQueueEvent(this, event);
@@ -276,13 +279,20 @@ void MonitorPanel::on_timer(wxTimerEvent& event)
 void MonitorPanel::on_select_printer(wxCommandEvent& event)
 {
     Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
+    const std::string requested_dev_id = event.GetString().ToStdString();
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MonitorPanel::on_select_printer requested_dev_id="
+                            << requested_dev_id << " device_manager=" << (dev ? "set" : "null");
     if (!dev) return;
 
     if ( dev->get_selected_machine() && (dev->get_selected_machine()->get_dev_id() != event.GetString().ToStdString()) && m_hms_panel) {
         m_hms_panel->clear_hms_tag();
     }
 
-    if (!dev->set_selected_machine(event.GetString().ToStdString()))
+    const bool selected = dev->set_selected_machine(requested_dev_id);
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MonitorPanel::on_select_printer set_selected_machine result="
+                            << selected << " selected_dev_id="
+                            << (dev->get_selected_machine() ? dev->get_selected_machine()->get_dev_id() : "<null>");
+    if (!selected)
         return;
 
     set_default();

src/slic3r/GUI/MultiMachine.cpp

@@ -3,6 +3,7 @@
 
 #include "GUI_App.hpp"
 #include "MainFrame.hpp"
+#include "DeviceCore/DevConfigUtil.h"
 
 namespace Slic3r {
 namespace GUI {
@@ -108,21 +109,12 @@ bool DeviceItem::is_blocking_printing(MachineObject* obj_)
 {
     DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
     if (!dev) return true;
-    auto target_model = obj_->printer_type;
     std::string source_model = "";
 
     PresetBundle* preset_bundle = wxGetApp().preset_bundle;
     source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
 
-    if (source_model != target_model) {
-        std::vector<std::string> compatible_machine = obj_->get_compatible_machine();
-        vector<std::string>::iterator it = find(compatible_machine.begin(), compatible_machine.end(), source_model);
-        if (it == compatible_machine.end()) {
-            return true;
-        }
-    }
-
-    return false;
+    return !DevPrinterConfigUtil::is_printer_model_compatible(source_model, *obj_);
 }
 
 void DeviceItem::update_item(const DeviceItem* item)

src/slic3r/GUI/PartSkipDialog.hpp

@@ -159,4 +159,4 @@ private:
     void OnApplyDialog(wxCommandEvent &event);
 };
 
-}} // namespace Slic3r::GUI
+}} // namespace Slic3r::GUI

src/slic3r/GUI/Plater.cpp

@@ -727,6 +727,7 @@ struct Sidebar::priv
     ScalableButton *  m_bpButton_add_filament;
     ScalableButton *  m_bpButton_del_filament;
     ScalableButton *  m_bpButton_ams_filament;
+    bool              m_ams_sync_button_show{true}; // last applied AMS sync button visibility
     ScalableButton *  m_bpButton_set_filament;
     int m_menu_filament_id = -1;
 
@@ -2002,12 +2003,14 @@ bool Sidebar::priv::sync_extruder_list(bool &only_external_material, bool is_man
     std::string machine_print_name = obj->get_show_printer_type();
     PresetBundle *preset_bundle = wxGetApp().preset_bundle;
     std::string target_model_id  = preset_bundle->printers.get_selected_preset().get_printer_type(preset_bundle);
-    Preset* machine_preset = get_printer_preset(obj);
-    if (!machine_preset) {
+    const bool optional_printer_model = DevPrinterConfigUtil::is_optional_printer_model_id(obj->printer_type);
+    const bool optional_target_model  = DevPrinterConfigUtil::is_optional_printer_model_id(target_model_id);
+    Preset* machine_preset = optional_printer_model ? nullptr : get_printer_preset(obj);
+    if (!optional_printer_model && !optional_target_model && !machine_preset) {
         BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << __LINE__ << "check error: machine_preset empty";
         return false;
     }
-    if (machine_print_name != target_model_id) {
+    if (!optional_printer_model && !optional_target_model && machine_print_name != target_model_id) {
         MessageDialog dlg(this->plater, _L("The currently selected machine preset is inconsistent with the connected printer type.\n"
                                             "Are you sure to continue syncing?"), _L("Sync printer information"), wxICON_WARNING | wxYES | wxNO);
         if (dlg.ShowModal() == wxID_NO) {
@@ -2199,6 +2202,11 @@ void Sidebar::priv::update_sync_status(const MachineObject *obj)
         return;
     }
 
+    if (DevPrinterConfigUtil::is_optional_printer_model_id(obj->printer_type)) {
+        clear_all_sync_status();
+        return;
+    }
+
     bool printer_synced = false;
     // 1. update printer status
     const Preset &cur_preset = wxGetApp().preset_bundle->printers.get_edited_preset();
@@ -3420,6 +3428,22 @@ void Sidebar::remove_unused_filament_combos(const size_t current_extruder_count)
     }
 }
 
+void Sidebar::update_ams_sync_button()
+{
+    if (!p->m_bpButton_ams_filament || !wxGetApp().preset_bundle)
+        return;
+    // BBL printers always advertise AMS sync; other agents follow the active
+    // agent's filament sync mode, which flips to subscription only after the
+    // printer's get_capabilities reply arrives.
+    const bool show = wxGetApp().preset_bundle->use_bbl_network() ||
+                      (wxGetApp().getAgent() && wxGetApp().getAgent()->get_filament_sync_mode() != FilamentSyncMode::none);
+    if (p->m_ams_sync_button_show == show)
+        return;
+    p->m_ams_sync_button_show = show;
+    p->m_bpButton_ams_filament->Show(show);
+    p->m_bpButton_ams_filament->GetParent()->Layout();
+}
+
 void Sidebar::update_all_preset_comboboxes()
 {
     PresetBundle &preset_bundle = *wxGetApp().preset_bundle;
@@ -3437,7 +3461,7 @@ void Sidebar::update_all_preset_comboboxes()
         //p->btn_connect_printer->Hide();
         p->m_printer_connect->Hide();
         //only show sync-ams button for BBL printer
-        p->m_bpButton_ams_filament->Show();
+        update_ams_sync_button();
         //update print button default value for bbl or third-party printer
         p_mainframe->set_print_button_to_default(MainFrame::PrintSelectType::ePrintPlate);
     } else {
@@ -3446,11 +3470,7 @@ void Sidebar::update_all_preset_comboboxes()
         p->m_printer_connect->Show(!use_printer_agents);
 
         // ORCA: show/hide sync-ams button based on filament sync mode
-        auto agent = wxGetApp().getAgent();
-        if (agent && agent->get_filament_sync_mode() != FilamentSyncMode::none)
-            p->m_bpButton_ams_filament->Show();
-        else
-            p->m_bpButton_ams_filament->Hide();
+        update_ams_sync_button();
 
         // Orca: with "Support 3MF as gcode" (use_3mf) the local export is a .gcode.3mf bundle, so when no
         // printer host/IP is configured the default action is "Export plate sliced file" (mirrors the
@@ -5799,11 +5819,30 @@ void Sidebar::load_ams_list(MachineObject* obj)
         filament_ams_list = build_filament_ams_list(obj);
     }
 
-    bool device_change     = false;
     const std::string& device = obj ? obj->get_dev_id() : "";
-    if (p->ams_list_device != device) {
+    const bool same_device = p->ams_list_device == device;
+
+    // Keep sync metadata out of the device payload, but preserve it across a
+    // subscription refresh when the physical filament in a slot is unchanged.
+    // Otherwise the refreshed configs differ only by the missing
+    // filament_changed key, causing combo boxes to rebuild and lose their
+    // transient post-sync badges.
+    auto &previous_filament_ams_list = wxGetApp().preset_bundle->filament_ams_list;
+    for (auto &entry : filament_ams_list) {
+        auto previous = previous_filament_ams_list.find(entry.first);
+        const auto *previous_changed = previous == previous_filament_ams_list.end() ? nullptr :
+                                       dynamic_cast<const ConfigOptionBool *>(previous->second.option("filament_changed"));
+        if (!same_device || previous_changed == nullptr ||
+            previous->second.opt_string("filament_id", 0u) != entry.second.opt_string("filament_id", 0u)) {
+            continue;
+        }
+        entry.second.set_key_value("filament_changed",
+                                   new ConfigOptionBool{previous_changed->value});
+    }
+
+    bool device_change     = !same_device;
+    if (device_change) {
         p->ams_list_device = device;
-        device_change      = true;
     }
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": %1% items") % filament_ams_list.size();
     if (wxGetApp().preset_bundle->filament_ams_list == filament_ams_list && !device_change)
@@ -5813,9 +5852,27 @@ void Sidebar::load_ams_list(MachineObject* obj)
     wxGetApp().preset_bundle->filament_ams_list = filament_ams_list;
 
     for (auto c : p->combos_filament){
+        c->set_sync_badge(false);
         c->update();
-        if (device_change) {
-            c->ShowBadge(false);//change printer,then clear badge
+    }
+
+    if (!device_change) {
+        size_t combo_index = 0;
+        for (const auto &entry : filament_ams_list) {
+            const auto &tray = entry.second;
+            const bool has_filament = !tray.opt_string("filament_id", 0u).empty();
+            const bool is_placeholder = tray.has("filament_slot_placeholder") &&
+                                         tray.opt_bool("filament_slot_placeholder", 0u);
+            if (!has_filament && !is_placeholder) {
+                continue;
+            }
+            if (combo_index >= p->combos_filament.size()) {
+                break;
+            }
+            const auto *filament_changed = dynamic_cast<const ConfigOptionBool *>(tray.option("filament_changed"));
+            p->combos_filament[combo_index]->set_sync_badge(
+                has_filament && !is_placeholder && filament_changed != nullptr && filament_changed->value);
+            ++combo_index;
         }
     }
 
@@ -5989,18 +6046,32 @@ void Sidebar::sync_ams_list(bool is_from_big_sync_btn)
         auto tip     = sync_color_only ? _L("Only filament color information has been synchronized from printer.") :
                                          _L("Filament type and color information have been synchronized, but slot information is not included.");
         c->SetToolTip(tip);
-        c->ShowBadge(true);
+        c->set_sync_badge(true);
     };
     { // badge ams filament
         clear_combos_filament_badge();
         if (sync_result.direct_sync) {
-            // Orca: PresetBundle::sync_ams_list rebuilds combos_filament
-            // 1:1 from the AMS trays that produce a combo (loaded trays + placeholders; non-placeholder
-            // empty trays are skipped), so every resulting combo is AMS-sourced and gets a badge. The
-            // previous per-tray index walked the full filament_ams_list (including the skipped empties),
-            // so an empty slot before a loaded one dropped the badge for the trailing filaments.
-            for (auto &c : p->combos_filament) {
-                badge_combox_filament(c);
+            // A placeholder contributes a preserved project filament to the
+            // overwrite result, but it is not AMS-sourced and must not get a
+            // sync badge. Non-placeholder empty trays are omitted entirely.
+            size_t combo_index = 0;
+            for (const auto &entry : wxGetApp().preset_bundle->filament_ams_list) {
+                const auto &tray = entry.second;
+                const bool has_filament = !tray.opt_string("filament_id", 0u).empty();
+                const bool is_placeholder = tray.has("filament_slot_placeholder") &&
+                                             tray.opt_bool("filament_slot_placeholder", 0u);
+                if (!has_filament && !is_placeholder) {
+                    continue;
+                }
+                if (combo_index >= p->combos_filament.size()) {
+                    break;
+                }
+                if (is_placeholder) {
+                    p->combos_filament[combo_index]->set_sync_badge(false);
+                } else {
+                    badge_combox_filament(p->combos_filament[combo_index]);
+                }
+                ++combo_index;
             }
         }
     }
@@ -6268,6 +6339,11 @@ template<typename T> void setup_dialog_position(T& info)
 
 void Sidebar::pop_sync_nozzle_and_ams_dialog() {
     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " begin pop_sync_nozzle_and_ams_dialog";
+    auto agent = wxGetApp().getAgent();
+    if (!agent || agent->get_filament_sync_mode() == FilamentSyncMode::none) {
+        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << " filament synchronization is not supported; skipping dialog";
+        return;
+    }
     wxTheApp->CallAfter([this]() {
         SyncNozzleAndAmsDialog::InputInfo temp_na_info;
         wxPoint                           big_btn_pt;
@@ -6399,17 +6475,14 @@ void Sidebar::clear_combos_filament_badge()
 {
     auto &combos_filament = p->combos_filament;
     for (auto &c : combos_filament) { // clear flag
-        c->ShowBadge(false);
+        c->set_sync_badge(false);
     }
 }
 
 void Sidebar::udpate_combos_filament_badge() {
     auto &combos_filament = p->combos_filament;
     for (auto &c : combos_filament) {
-        auto selection   = c->GetSelection();
-        auto select_flag = c->GetFlag(selection);
-        auto ok          = select_flag == (int) PresetComboBox::FilamentAMSType::FROM_AMS;
-        c->ShowBadge(ok);
+        c->update_badge_according_flag();
     }
 
 }
@@ -12219,7 +12292,7 @@ void Plater::priv::on_select_preset(wxCommandEvent &evt)
             sidebar->auto_calc_flushing_volumes(idx);
         }
         auto select_flag = combo->GetFlag(selection);
-        combo->ShowBadge(select_flag == (int)PresetComboBox::FilamentAMSType::FROM_AMS);
+        combo->set_sync_badge(select_flag == (int)PresetComboBox::FilamentAMSType::FROM_AMS);
         q->on_filament_change(idx);
     }
     bool select_preset = !combo->selection_is_changed_according_to_physical_printers();
@@ -20817,9 +20890,14 @@ bool Plater::is_same_printer_for_connected_and_selected(bool popup_warning)
     }
     if (!check_printer_initialized(obj, true, popup_warning))
         return false;
-    Preset *      machine_preset     = get_printer_preset(obj);
-    if (!machine_preset)
+    const std::string machine_model = obj->printer_type;
+    PresetBundle *preset_bundle = wxGetApp().preset_bundle;
+    const std::string selected_model = preset_bundle ? preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) : std::string();
+    if (!DevPrinterConfigUtil::is_optional_printer_model_id(machine_model) &&
+        !DevPrinterConfigUtil::is_optional_printer_model_id(selected_model) &&
+        !get_printer_preset(obj)) {
         return false;
+    }
 
     if (wxGetApp().is_blocking_printing()) {
         if (popup_warning) {
@@ -22087,10 +22165,14 @@ void Plater::update_machine_sync_status()
     DeviceManager *dev_maneger = wxGetApp().getDeviceManager();
     if (!dev_maneger) {
         GUI::wxGetApp().sidebar().update_sync_status(nullptr);
+        GUI::wxGetApp().sidebar().update_ams_sync_button();
         return;
     }
     MachineObject *obj = wxGetApp().getDeviceManager()->get_selected_machine();
     GUI::wxGetApp().sidebar().update_sync_status(obj);
+    // The agent's sync mode flips once the printer's get_capabilities reply
+    // arrives; re-evaluate the filament-sync button on every device update.
+    GUI::wxGetApp().sidebar().update_ams_sync_button();
 }
 
 bool Plater::get_machine_sync_status()

src/slic3r/GUI/Plater.hpp

@@ -169,6 +169,8 @@ public:
     void init_filament_combo(PlaterPresetComboBox **combo, const int filament_idx);
     void remove_unused_filament_combos(const size_t current_extruder_count);
     void update_all_preset_comboboxes();
+    // Show/hide the AMS filament-sync button from the active agent's sync mode.
+    void update_ams_sync_button();
     //void update_partplate(PartPlateList& list);
     void update_presets(Slic3r::Preset::Type preset_type);
     //BBS

src/slic3r/GUI/PluginStatus.hpp

@@ -11,6 +11,7 @@ namespace Slic3r
             // IMPORTANT: ordinal order is the Plugins dialog Status sort priority.
             Activated,
             Error,
+            RuntimeError,
             Inactive,
             Loading
         };
@@ -21,11 +22,28 @@ namespace Slic3r
             {
             case PluginStatus::Activated: return "Activated";
             case PluginStatus::Error: return "Error";
+            case PluginStatus::RuntimeError: return "RuntimeError";
             case PluginStatus::Inactive: return "Inactive";
             case PluginStatus::Loading: return "Loading";
             }
 
             return "Inactive";
         }
+
+        // why: a plugin whose module is live but whose catalog carries an error is a
+        //   RUNTIME fault (e.g. a capability rejected at register time) - it stays
+        //   loaded/checked and is only flagged, distinct from a load-time Error where
+        //   the module never came up. Loading wins over both so an in-flight reload
+        //   never flashes an error.
+        inline PluginStatus resolve_plugin_status(bool loading, bool has_error, bool is_loaded)
+        {
+            if (loading)
+                return PluginStatus::Loading;
+            if (has_error)
+                return is_loaded ? PluginStatus::RuntimeError : PluginStatus::Error;
+            if (is_loaded)
+                return PluginStatus::Activated;
+            return PluginStatus::Inactive;
+        }
     }
 } // namespace Slic3r::GUI

src/slic3r/GUI/PluginsDialog.cpp

@@ -237,6 +237,7 @@ nlohmann::json build_plugin_payload_item(const PluginDialogItem& dialog_item)
     payload_item["label"]                 = dialog_item.display_name;
     payload_item["source"]                = to_string(dialog_item.source);
     payload_item["status"]                = to_string(dialog_item.status);
+    payload_item["is_loaded"]             = dialog_item.is_loaded;
     payload_item["error"]                 = dialog_item.error_text;
     payload_item["update_status"]         = to_string(dialog_item.update_status);
     payload_item["unauthorized"]          = dialog_item.unauthorized;
@@ -381,14 +382,7 @@ PluginDialogItem build_plugin_dialog_item(const PluginDescriptor& descriptor)
     item.sharing_token = descriptor.sharing_token;
     item.thumbnail_url = descriptor.thumbnail_url;
 
-    if (item.loading)
-        item.status = PluginStatus::Loading;
-    else if (item.has_error)
-        item.status = PluginStatus::Error;
-    else if (item.is_loaded)
-        item.status = PluginStatus::Activated;
-    else
-        item.status = PluginStatus::Inactive;
+    item.status = resolve_plugin_status(item.loading, item.has_error, item.is_loaded);
 
     item.available_actions        = evaluate_action_policy(item);
     const bool has_enabled_script = std::any_of(item.capabilities.begin(), item.capabilities.end(),
@@ -664,6 +658,9 @@ void PluginsDialog::toggle_plugin(const std::string& plugin_key, bool enabled)
         }
 
         BOOST_LOG_TRIVIAL(info) << "Plugin unloaded from Plugins dialog: " << plugin_key;
+        // A user-disabled plugin has no meaningful error state.
+        if (!manager.clear_plugin_error(plugin_key))
+            BOOST_LOG_TRIVIAL(warning) << "Failed to clear plugin error for " << plugin_key << " (failed to find)";
         // A prior activation of this plugin is moot now; drop it so no stale "Activated" arrives later.
         if (m_activating_plugin_key == plugin_key)
             m_activating_plugin_key.clear();

src/slic3r/GUI/PrePrintChecker.cpp

@@ -63,6 +63,7 @@ std::string PrePrintChecker::get_print_status_info(PrintDialogStatus status)
     case PrintStatusRackReading: return "PrintStatusRackReading";
     case PrintStatusRackNozzleNumUnmeetWarning: return "PrintStatusRackNozzleNumUnmeetWarning";
     case PrintStatusHasUnreliableNozzleWarning: return "PrintStatusHasUnreliableNozzleWarning";
+    case PrintStatusOptionalPrinterModel: return "PrintStatusOptionalPrinterModel";
     case PrintStatusWarningExtFilamentNotMatch: return "PrintStatusWarningExtFilamentNotMatch";
     case PrintStatusFilamentWarningNozzleHRC: return "PrintStatusFilamentWarningNozzleHRC";
     case PrintStatusTPUUnsupportCaliOn: return "PrintStatusTPUUnsupportCaliOn";
@@ -104,6 +105,7 @@ wxString PrePrintChecker::get_pre_state_msg(PrintDialogStatus status)
     case PrintStatusNeedConsistencyUpgrading: return _L("Cannot send the print job to a printer whose firmware must be updated.");
     case PrintStatusBlankPlate: return _L("Cannot send a print job for an empty plate.");
     case PrintStatusTimelapseNoSdcard: return _L("Storage needs to be inserted to record timelapse.");
+    case PrintStatusOptionalPrinterModel: return _L("The selected printer model could not be identified, so compatibility with the print file configuration cannot be verified. Please verify the printer preset before sending.");
     case PrintStatusMixAmsAndVtSlotWarning: return _L("You have selected both external and AMS filaments for an extruder. You will need to manually switch the external filament during printing.");
     case PrintStatusTPUUnsupportAutoCali: return _L("TPU 90A/TPU 85A is too soft and does not support automatic Flow Dynamics calibration.");
     case PrintStatusWarningKvalueNotUsed: return _L("Set dynamic flow calibration to 'OFF' to enable custom dynamic flow value.");
@@ -379,4 +381,3 @@ bool PrinterMsgPanel::UpdateInfos(const std::vector<prePrintInfo>& infos)
 }
 };
 
-

src/slic3r/GUI/PrePrintChecker.hpp

@@ -112,6 +112,7 @@ enum PrintDialogStatus : unsigned int {
     // Orca: a nozzle diameter that differs from the one the printer remembers is a warning,
     // not an error, so non-standard nozzles can still be printed with.
     PrintStatusNozzleDiameterMismatch,
+    PrintStatusOptionalPrinterModel,
     PrintStatusPrinterWarningEnd,
 
     // Warnings for filament

src/slic3r/GUI/PresetComboBoxes.cpp

@@ -361,7 +361,8 @@ wxString PresetComboBox::get_preset_item_name(unsigned int index)
                 return GetString(index);
             }
 
-            std::map<std::string, MachineObject *> machine_list = dev->get_my_machine_list();
+            std::map<std::string, MachineObject *> machine_list =
+                dev->get_my_machine_list(dev->get_current_printer_agent_id());
             if (machine_list.empty()) {
                 assert(false);
                 m_selected_dev_id.clear();
@@ -479,7 +480,8 @@ void PresetComboBox::add_connected_printers(std::string selected, bool alias_nam
     if (!dev)
         return;
 
-    std::map<std::string, MachineObject *> machine_list = dev->get_my_machine_list();
+    std::map<std::string, MachineObject *> machine_list =
+        dev->get_my_machine_list(dev->get_current_printer_agent_id());
     if (machine_list.empty())
         return;
 
@@ -999,7 +1001,13 @@ void PlaterPresetComboBox::update_badge_according_flag() {
     auto selection   = GetSelection();
     auto select_flag = GetFlag(selection);
     auto ok          = select_flag == (int) PresetComboBox::FilamentAMSType::FROM_AMS;
-    ShowBadge(ok);
+    ShowBadge(m_sync_badge || ok);
+}
+
+void PlaterPresetComboBox::set_sync_badge(bool show)
+{
+    m_sync_badge = show;
+    ShowBadge(show);
 }
 
 bool PlaterPresetComboBox::switch_to_tab()

src/slic3r/GUI/PresetComboBoxes.hpp

@@ -205,6 +205,7 @@ public:
     void msw_rescale() override;
     void OnSelect(wxCommandEvent& evt) override;
     void update_badge_according_flag();
+    void set_sync_badge(bool show);
 
     FilamentColor get_cur_color_info();
     void show_default_color_picker();
@@ -214,6 +215,7 @@ public:
 private:
     // BBS
     wxColor m_color;
+    bool    m_sync_badge{false};
 };
 
 

src/slic3r/GUI/ReleaseNote.cpp

@@ -1736,7 +1736,8 @@ void InputIpAddressDialog::set_machine_obj(MachineObject* obj)
     auto str_ip = m_input_ip->GetTextCtrl()->GetValue();
     auto str_access_code = m_input_access_code->GetTextCtrl()->GetValue();
     // ORCA enabling / disabling buttons with conditions enough to change its style
-    m_button_ok->Enable(isIp(str_ip.ToStdString()) && str_access_code.Length() == 8);
+    m_button_ok->Enable(isIp(str_ip.ToStdString()) &&
+                        (str_access_code.IsEmpty() || str_access_code.Length() >= 8));
 
     Layout();
     Fit();
@@ -1801,6 +1802,8 @@ void InputIpAddressDialog::on_ok(wxMouseEvent& evt)
     m_trouble_shoot->Hide();
     std::string str_ip = m_input_ip->GetTextCtrl()->GetValue().ToStdString();
     std::string str_access_code = m_input_access_code->GetTextCtrl()->GetValue().ToStdString();
+    if (str_access_code.empty())
+        str_access_code = "88888888";
     std::string str_name = m_input_printer_name->GetTextCtrl()->GetValue().Strip(wxString::both).ToStdString();
     // Serial number should not contain lower case letters, and bambu_network plugin crashes
     // if user entered the wrong serial number, so we call `Upper()` here.
@@ -1835,6 +1838,8 @@ void InputIpAddressDialog::on_send_retry()
     Fit();
     wxString ip              = m_input_ip->GetTextCtrl()->GetValue();
     wxString str_access_code = m_input_access_code->GetTextCtrl()->GetValue();
+    if (str_access_code.IsEmpty())
+        str_access_code = "88888888";
 
     // check support function
     if (!m_obj) return;
@@ -2056,7 +2061,7 @@ void InputIpAddressDialog::on_text(wxCommandEvent &evt)
     auto str_ip              = m_input_ip->GetTextCtrl()->GetValue();
     auto str_access_code     = m_input_access_code->GetTextCtrl()->GetValue();
 
-    if (str_access_code.empty()) {
+    if (str_access_code.IsEmpty()) {
         str_access_code = "88888888";
     }
 
@@ -2072,7 +2077,8 @@ void InputIpAddressDialog::on_text(wxCommandEvent &evt)
     }
 
     // ORCA enabling / disabling buttons with conditions enough to change its style
-    bool enable_btns = isIp(str_ip.ToStdString()) && str_access_code.Length() == 8 && invalid_access_code;
+    bool valid_access_code_length = str_access_code.IsEmpty() || str_access_code.Length() >= 8;
+    bool enable_btns = isIp(str_ip.ToStdString()) && valid_access_code_length && invalid_access_code;
     m_button_manual_setup->Enable(enable_btns);
     m_button_ok->Enable(enable_btns);
 

src/slic3r/GUI/SelectMachine.cpp

@@ -21,6 +21,7 @@
 #include "Jobs/PlaterWorker.hpp"
 
 #include "DeviceCore/DevConfig.h"
+#include "DeviceCore/DevConfigUtil.h"
 #include "DeviceCore/DevNozzleSystem.h"
 #include "DeviceCore/DevNozzleRack.h"
 #include "DeviceCore/DevExtensionTool.h"
@@ -1125,7 +1126,10 @@ bool SelectMachineDialog::do_ams_mapping(MachineObject *obj_,bool use_ams)
 
     int filament_result = 0;
     std::vector<bool> map_opt;  //four values: use_left_ams, use_right_ams, use_left_ext, use_right_ext
-    if (nozzle_nums > 1){
+    // Orca: only do the per-physical-extruder left/right split when the device actually reports
+    // 2+ extruders. A non-BBL multi-nozzle printer (e.g. Snapmaker U1) reports a single extruder
+    // with one filament pool, so it maps as a single surface via the else branch below.
+    if (nozzle_nums > 1 && obj_->GetExtderSystem()->GetTotalExtderCount() > 1){
         //get nozzle property, the extders are same?
         if (true/*!can_hybrid_mapping(obj_get_extder_data())*/){
             std::vector<FilamentInfo>           m_ams_mapping_result_left, m_ams_mapping_result_right;
@@ -2312,8 +2316,10 @@ void SelectMachineDialog::show_status(PrintDialogStatus status, std::vector<wxSt
     } else if (status == PrintDialogStatus::PrintStatusNoSdcard) {
         Enable_Refresh_Button(true);
         Enable_Send_Button(false);
-    }else if (status == PrintDialogStatus::PrintStatusUnsupportedPrinter) {
+    }else if (status == PrintDialogStatus::PrintStatusUnsupportedPrinter ||
+              status == PrintDialogStatus::PrintStatusOptionalPrinterModel) {
         wxString msg_text;
+        const bool block_send = status == PrintDialogStatus::PrintStatusUnsupportedPrinter;
         try
         {
             DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
@@ -2339,17 +2345,21 @@ void SelectMachineDialog::show_status(PrintDialogStatus status, std::vector<wxSt
 
             auto target_print_name = wxString(DevPrinterConfigUtil::get_printer_display_name(target_model_id));
             target_print_name.Replace(wxT("Bambu Lab "), wxEmptyString);
-            msg_text = wxString::Format(_L("The selected printer (%s) is incompatible with the print file configuration (%s). Please adjust the printer preset in the prepare page or choose a compatible printer on this page."), sourcet_print_name, target_print_name);
+            if (block_send) {
+                msg_text = wxString::Format(_L("The selected printer (%s) is incompatible with the print file configuration (%s). Please adjust the printer preset in the prepare page or choose a compatible printer on this page."), sourcet_print_name, target_print_name);
+            } else {
+                msg_text = wxString::Format(_L("The selected printer (%s) has an unknown model, so compatibility with the print file configuration (%s) cannot be verified. Please verify the printer preset before sending."), sourcet_print_name, target_print_name);
+            }
 
 
             msg = msg_text;
             Enable_Refresh_Button(true);
-            Enable_Send_Button(false);
+            Enable_Send_Button(!block_send);
         }
         catch (...)
         {
             Enable_Refresh_Button(true);
-            Enable_Send_Button(false);
+            Enable_Send_Button(!block_send);
         }
 
 
@@ -2526,15 +2536,7 @@ bool SelectMachineDialog::is_blocking_printing(MachineObject* obj_)
         }
     }
 
-    if (source_model != target_model) {
-        std::vector<std::string> compatible_machine = obj_->get_compatible_machine();
-        vector<std::string>::iterator it = find(compatible_machine.begin(), compatible_machine.end(), source_model);
-        if (it == compatible_machine.end()) {
-            return true;
-        }
-    }
-
-    return false;
+    return !DevPrinterConfigUtil::is_printer_model_compatible(source_model, *obj_);
 }
 
 static std::unordered_set<int> _get_used_nozzle_idxes()
@@ -2622,6 +2624,10 @@ bool SelectMachineDialog::is_same_printer_model()
     if(preset_bundle == nullptr) return result;
     const auto source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
     const auto target_model = obj_->printer_type;
+    if (DevPrinterConfigUtil::is_optional_printer_model_id(source_model) ||
+        DevPrinterConfigUtil::is_optional_printer_model_id(target_model)) {
+        return true;
+    }
     // Orca: ignore P1P -> P1S
     if (source_model != target_model) {
         if ((source_model == "C12" && target_model == "C11") || (source_model == "C11" && target_model == "C12") ||
@@ -3696,10 +3702,32 @@ void SelectMachineDialog::on_send_print()
     m_print_job->on_success([this]() { finish_mode(); });
 
     m_print_job->on_check_ip_address_fail([this]() {
-        wxCommandEvent* evt = new wxCommandEvent(EVT_CLEAR_IPADDRESS);
-        wxQueueEvent(this, evt);
-        wxGetApp().show_ip_address_enter_dialog();
-     });
+        // Invoked from the PrintJob worker thread when the LAN pre-flight (file upload
+        // verification) fails. Marshal device/UI access to the main thread.
+        CallAfter([this]()
+        {
+            // Reset the dialog out of sending mode so the user can retry.
+            wxCommandEvent* evt = new wxCommandEvent(EVT_CLEAR_IPADDRESS);
+            wxQueueEvent(this, evt);
+
+            DeviceManager* dev = wxGetApp().getDeviceManager();
+            MachineObject* obj = dev ? dev->get_selected_machine() : nullptr;
+
+            if (obj && obj->is_connected())
+            {
+                // Connected: failed on file upload
+                MessageDialog dlg(this,
+                                  _L("Failed to upload the file to the printer's storage. Please try again."),
+                                  _L("Send Failed"), wxOK | wxICON_ERROR);
+                dlg.ShowModal();
+            }
+            else
+            {
+                // Not connected: reenter ip and access code
+                wxGetApp().show_ip_address_enter_dialog();
+            }
+        });
+    });
 
     // update ota version
     NetworkAgent* agent = wxGetApp().getAgent();
@@ -4533,11 +4561,13 @@ bool SelectMachineDialog::CheckErrorExtruderNozzleWithSlicing(MachineObject* obj
 
             // check nozzle data valid
             {
-                if (installed_ext_nozzle.GetNozzleType() == NozzleType::ntUndefine ||
-                    installed_ext_nozzle.GetNozzleDiameter() <= 0.0f) {
-                    show_status(PrintDialogStatus::PrintStatusNozzleDataInvalid);
-                    return false;
-                }
+                // Commented out the following as ntUndefine and 0.0f are default values
+                // (signifying that the value is not given) that should PASS, not fail
+                // if (installed_ext_nozzle.GetNozzleType() == NozzleType::ntUndefine ||
+                //     installed_ext_nozzle.GetNozzleDiameter() <= 0.0f) {
+                //     show_status(PrintDialogStatus::PrintStatusNozzleDataInvalid);
+                //     return false;
+                // }
 
                 if (obj_->is_nozzle_flow_type_supported() &&
                     installed_ext_nozzle.GetNozzleFlowType() == NozzleFlowType::NONE_FLOWTYPE) {
@@ -4566,7 +4596,10 @@ bool SelectMachineDialog::CheckErrorExtruderNozzleWithSlicing(MachineObject* obj
 
             // check nozzle diameter
             {
-                if (slicing_ext.nozzle_diameter != installed_ext_nozzle.GetNozzleDiameter()) {
+                // 0.0f is default when there is no nozzle diameter is given.
+                // In nozzle_diameter == 0.0f case, it passes and does not require a comparison
+                if (installed_ext_nozzle.GetNozzleDiameter() > 0.0f &&
+                    slicing_ext.nozzle_diameter != installed_ext_nozzle.GetNozzleDiameter()) {
                     std::vector<wxString> msg_params;
                     if (ext_sys->GetTotalExtderCount() == 2) {
                         const wxString& mismatch_nozzle_str = _get_nozzle_name(ext_sys->GetTotalExtderCount(), slicing_ext_idx);
@@ -4760,6 +4793,22 @@ void SelectMachineDialog::update_show_status(MachineObject* obj_)
         return;
     }
 
+    bool has_optional_printer_model = DevPrinterConfigUtil::is_optional_printer_model_id(obj_->printer_type);
+    if (m_print_type == PrintFromType::FROM_NORMAL) {
+        PresetBundle* preset_bundle = wxGetApp().preset_bundle;
+        has_optional_printer_model = has_optional_printer_model ||
+            (preset_bundle && DevPrinterConfigUtil::is_optional_printer_model_id(
+                preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle)));
+    } else if (m_print_type == PrintFromType::FROM_SDCARD_VIEW && !m_required_data_plate_data_list.empty()) {
+        has_optional_printer_model = has_optional_printer_model ||
+            DevPrinterConfigUtil::is_optional_printer_model_id(
+                m_required_data_plate_data_list[m_print_plate_idx]->printer_model_id);
+    }
+
+    if (has_optional_printer_model) {
+        show_status(PrintDialogStatus::PrintStatusOptionalPrinterModel);
+    }
+
     if (is_blocking_printing(obj_)) {
         show_status(PrintDialogStatus::PrintStatusUnsupportedPrinter);
         return;
@@ -5482,8 +5531,8 @@ void SelectMachineDialog::reset_and_sync_ams_list()
                 item = new MaterialItem(m_filament_left_panel, colour_rgb, _L(display_materials[extruder]));
                 m_sizer_ams_mapping_left->Add(item, 0, wxALL, FromDIP(5));
             }
-            else if (m_filaments_map[extruder] == 2)
-            {
+            else // map == 2, or (non-BBL multi-nozzle) 3+; update_material_item_pos() collapses
+            {    // these into the single panel when the device reports < 2 extruders.
                 item = new MaterialItem(m_filament_right_panel, colour_rgb, _L(display_materials[extruder]));
                 m_sizer_ams_mapping_right->Add(item, 0, wxALL, FromDIP(5));
             }

src/slic3r/GUI/SendToPrinter.cpp

@@ -24,6 +24,7 @@
 #include "BitmapCache.hpp"
 
 #include "DeviceCore/DevManager.h"
+#include "DeviceCore/DevConfigUtil.h"
 #include "DeviceCore/DevStorage.h"
 #include "slic3r/Utils/FileTransferUtils.hpp"
 
@@ -300,7 +301,7 @@ SendToPrinterDialog::SendToPrinterDialog(Plater *plater)
     m_storage_panel->Layout();
 
     // try to connect
-    m_statictext_printer_msg = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_CENTER_HORIZONTAL);
+    m_statictext_printer_msg = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(FromDIP(400), -1), wxALIGN_CENTER_HORIZONTAL);
     m_statictext_printer_msg->SetFont(::Label::Body_13);
     m_statictext_printer_msg->SetForegroundColour(*wxBLACK);
     m_statictext_printer_msg->Hide();
@@ -760,9 +761,25 @@ void SendToPrinterDialog::update_priner_status_msg(wxString msg, bool is_warning
         if (str_new != str_old) {
             if (m_statictext_printer_msg->GetLabel() != msg) {
                 m_statictext_printer_msg->SetLabel(msg);
-                m_statictext_printer_msg->SetMinSize(wxSize(FromDIP(400), -1));
-                m_statictext_printer_msg->SetMaxSize(wxSize(FromDIP(400), -1));
-                m_statictext_printer_msg->Wrap(FromDIP(400));
+                const int wrap_width = FromDIP(400);
+                m_statictext_printer_msg->Wrap(wrap_width);
+                int line_count = 1;
+                const wxString wrapped_label = m_statictext_printer_msg->GetLabel();
+                for (size_t i = 0; i < wrapped_label.length(); ++i) {
+                    if (wrapped_label[i] == '\n')
+                        ++line_count;
+                }
+                wxCoord text_width = 0;
+                wxCoord text_height = 0;
+                m_statictext_printer_msg->GetTextExtent(msg, &text_width, &text_height);
+                const int extent_line_count = text_width > 0 ?
+                    std::max(1, (static_cast<int>(text_width) + wrap_width - 1) / wrap_width) : 1;
+                line_count = std::max(line_count, extent_line_count);
+                const int line_height = std::max(m_statictext_printer_msg->GetCharHeight(), static_cast<int>(text_height));
+                const int min_height = std::max(m_statictext_printer_msg->GetBestSize().GetHeight(),
+                                                line_count * line_height + FromDIP(2));
+                m_statictext_printer_msg->SetMinSize(wxSize(wrap_width, min_height));
+                m_statictext_printer_msg->SetMaxSize(wxDefaultSize);
                 m_statictext_printer_msg->Show();
                 Layout();
                 Fit();
@@ -1102,7 +1119,7 @@ void SendToPrinterDialog::update_user_printer()
     wxArrayString                         machine_list_name;
     std::map<std::string, MachineObject*> option_list;
 
-    option_list = dev->get_my_machine_list();
+    option_list = dev->get_my_machine_list(dev->get_current_printer_agent_id());
 
     // same machine only appear once
     for (auto it = option_list.begin(); it != option_list.end(); it++) {
@@ -1332,17 +1349,7 @@ bool SendToPrinterDialog::is_blocking_printing(MachineObject* obj_)
 
     PresetBundle* preset_bundle = wxGetApp().preset_bundle;
     auto source_model = preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle);
-    auto target_model = obj_->printer_type;
-
-    if (source_model != target_model) {
-        std::vector<std::string> compatible_machine = obj_->get_compatible_machine();
-        vector<std::string>::iterator it = find(compatible_machine.begin(), compatible_machine.end(), source_model);
-        if (it == compatible_machine.end()) {
-            return true;
-        }
-    }
-
-    return false;
+    return !DevPrinterConfigUtil::is_printer_model_compatible(source_model, *obj_);
 }
 
 void SendToPrinterDialog::Enable_Refresh_Button(bool en)
@@ -1486,6 +1493,9 @@ void SendToPrinterDialog::show_status(PrintDialogStatus status, std::vector<wxSt
         Enable_Send_Button(false);
         Enable_Refresh_Button(true);
     } else if (status == PrintDialogStatus::PrintStatusPublicInitFailed) {
+        wxString msg_text = _L(
+            "Failed to initialize the printer file transfer. Please check the connection and try again.");
+        update_print_status_msg(msg_text, true, true);
         Enable_Send_Button(false);
         Enable_Refresh_Button(true);
     } else if (status == PrintDialogStatus::PrintStatusPublicUploadFiled) {
@@ -1663,30 +1673,18 @@ extern void     refresh_agora_url(char const *device, char const *dev_ver, char
 void SendToPrinterDialog::GetConnection()
 {
     DeviceManager *dm  = GUI::wxGetApp().getDeviceManager();
+    MachineObject *obj = dm ? dm->get_selected_machine() : nullptr;
 
-    MachineObject *obj = dm->get_selected_machine();
-    if (obj == nullptr) {
+    if (!obj)
         BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : obj is empty";
-        m_connection_status = ConnectionStatus::NOT_START;
-    }
-
-    int remote_proto = obj->get_file_remote();
-    if (!remote_proto) {
+    if (obj && !obj->get_file_remote())
         BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : remote_proto is not support";
-        m_connection_status = ConnectionStatus::NOT_START;
-    }
+    if (obj && obj->is_camera_busy_off())
+    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : camera is busy";
 
-    if (obj->is_camera_busy_off()) {
-        BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " : camera is busy";
-        m_connection_status = ConnectionStatus::NOT_START;
-    }
+    NetworkAgent* agent = wxGetApp().getAgent();
 
-    NetworkAgent *agent         = wxGetApp().getAgent();
-    std::string   agent_version = agent ? agent->get_version() : "";
-    std::string   dev_ver       = obj->get_ota_version();
-    std::string   dev_id        = obj->get_dev_id();
-
-     if (m_url_timer && m_url_timer->IsRunning())
+    if (m_url_timer && m_url_timer->IsRunning())
      {
          m_url_timer->Stop();
      }
@@ -1709,19 +1707,40 @@ void SendToPrinterDialog::GetConnection()
          m_url_timer->GetId());
      m_url_timer->StartOnce(8000);
 
-    if (agent) {
+    if (obj && agent)
+    {
+        std::string dev_ver = obj->get_ota_version();
+        std::string dev_id = obj->get_dev_id();
+
         if (m_tcp_try_connect) {
             std::string devIP      = obj->get_dev_ip();
             std::string accessCode = obj->get_access_code();
             std::string url        = "bambu:///local/" + devIP + "?port=6000&user=" + "bblp" + "&passwd=" + accessCode;
-            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Connect method tcp";
-            m_filetransfer_tunnel  = std::make_unique<FileTransferTunnel>(module(), url);
-            m_filetransfer_tunnel->on_connection([this](bool is_success, int err_code, std::string error_msg) {
-                CallAfter([this, is_success, err_code, error_msg]() {
-                       OnConnection(is_success, err_code, error_msg);
+            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Connect method tcp, dev_id=" << dev_id
+                                    << ", dev_ip=" << devIP << ", access_code_len=" << accessCode.size();
+
+            try
+            {
+                m_filetransfer_tunnel = std::make_unique<FileTransferTunnel>(module(), url);
+                m_filetransfer_tunnel->on_connection([this](bool is_success, int err_code, std::string error_msg)
+                {
+                    CallAfter([this, is_success, err_code, error_msg]()
+                    {
+                        OnConnection(is_success, err_code, error_msg);
+                    });
                 });
-            });
-            m_filetransfer_tunnel->start_connect();
+                m_filetransfer_tunnel->start_connect();
+            }
+            catch (const std::exception& e)
+            {
+                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": tcp FileTransferTunnel unavailable for dev_id=" <<
+ dev_id
+                                           << " dev_ip=" << devIP << ": " << e.what();
+                if (m_url_timer && m_url_timer->IsRunning()) m_url_timer->Stop();
+                m_filetransfer_tunnel.reset();
+                m_connection_status = ConnectionStatus::CONNECTION_FAILED;
+                show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
+            }
         }
         else if (m_tutk_try_connect)
         {
@@ -1749,11 +1768,28 @@ void SendToPrinterDialog::GetConnection()
                 if (boost::algorithm::starts_with(url, "bambu:///"))
                 {
                     BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Connect method tutk";
-                    m_filetransfer_tunnel = std::make_unique<FileTransferTunnel>(module(), url);
-                    m_filetransfer_tunnel->on_connection([this](bool is_success, int err_code, std::string error_msg) {
-                        CallAfter([this, is_success, err_code, error_msg]() { OnConnection(is_success, err_code, error_msg); });
-                    });
-                    m_filetransfer_tunnel->start_connect();
+                    try
+                    {
+                        m_filetransfer_tunnel = std::make_unique<FileTransferTunnel>(module(), url);
+                        m_filetransfer_tunnel->on_connection(
+                            [this](bool is_success, int err_code, std::string error_msg)
+                            {
+                                CallAfter([this, is_success, err_code, error_msg]()
+                                {
+                                    OnConnection(is_success, err_code, error_msg);
+                                });
+                            });
+                        m_filetransfer_tunnel->start_connect();
+                    }
+                    catch (const std::exception& e)
+                    {
+                        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": tutk FileTransferTunnel unavailable: " << e.
+what();
+                        if (m_url_timer && m_url_timer->IsRunning()) m_url_timer->Stop();
+                        m_filetransfer_tunnel.reset();
+                        m_connection_status = ConnectionStatus::CONNECTION_FAILED;
+                        show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
+                    }
                 }
                 else
                 {
@@ -1852,8 +1888,17 @@ void SendToPrinterDialog::ResetTunnelAndJob()
 
 void SendToPrinterDialog::CreateMediaAbilityJob()
 {
-     nlohmann::json media_ability = {{"cmd_type", 7}};
-     m_filetransfer_mediability_job = std::make_unique<FileTransferJob>(module(), std::string(media_ability.dump()));
+    nlohmann::json media_ability = {{"cmd_type", 7}};
+    try
+    {
+        m_filetransfer_mediability_job = std::make_unique<FileTransferJob>(module(), std::string(media_ability.dump()));
+    }
+    catch (const std::exception& e)
+    {
+        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": FileTransferJob unavailable: " << e.what();
+         show_status(PrintDialogStatus::PrintStatusPublicInitFailed);
+         return;
+     }
      m_filetransfer_mediability_job->on_result([this](int res, int resp_ec, std::string json_res, std::vector<std::byte> bin_res) {
          //this pl
          CallAfter([this, res, resp_ec, json_res] {
@@ -1908,11 +1953,20 @@ void SendToPrinterDialog::CreateUploadFileJob(const std::string &path, const std
         {"cmd_type", 5},
     };
     upload_params["dest_storage"] = m_selected_storage;
-    upload_params["dest_name"]    = name; // filenme no path
-    upload_params["file_path"]    = path;
+    upload_params["dest_name"] = name; // filenme no path
+    upload_params["file_path"] = path;
 
-      BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Begin CreateUploadFileJob";
-    m_filetransfer_uploadfile_job = std::make_unique<FileTransferJob>(module(), std::string(upload_params.dump()));
+    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Begin CreateUploadFileJob";
+    try
+    {
+        m_filetransfer_uploadfile_job = std::make_unique<FileTransferJob>(module(), std::string(upload_params.dump()));
+    }
+    catch (const std::exception& e)
+    {
+        BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": FileTransferJob unavailable: " << e.what();
+        show_status(PrintDialogStatus::PrintStatusPublicUploadFiled);
+        return;
+    }
     m_filetransfer_uploadfile_job->on_result([this](int res, int resp_ec, std::string json_res, std::vector<std::byte> bin_res) { //
         CallAfter([this, res, resp_ec, json_res, bin_res] {
             UploadFileRessultCallback(res, resp_ec,json_res, bin_res);

src/slic3r/GUI/StatusPanel.cpp

@@ -22,6 +22,7 @@
 #include <wx/mstream.h>
 #include <wx/sstream.h>
 #include <wx/zstream.h>
+#include <chrono>
 
 #include "DeviceCore/DevBed.h"
 #include "DeviceCore/DevCtrl.h"
@@ -1462,7 +1463,7 @@ wxBoxSizer *StatusBasePanel::create_monitoring_page()
 #if !BBL_RELEASE_TO_PUBLIC
     m_staticText_timelapse->Show();
     m_bmToggleBtn_timelapse->Show();
-    m_bmToggleBtn_timelapse->Bind(wxEVT_TOGGLEBUTTON, [this](wxCommandEvent &e) {
+    m_bmToggleBtn_timelapse->Bind(wxEVT_TOGGLEBUTTON, [](wxCommandEvent &e) {
         if (e.IsChecked())
             wxGetApp().getAgent()->start_subscribe("tunnel");
         else
@@ -1493,27 +1494,26 @@ wxBoxSizer *StatusBasePanel::create_monitoring_page()
     m_setting_button->SetMinSize(wxSize(FromDIP(38), FromDIP(24)));
     m_setting_button->SetBackgroundColour(STATUS_TITLE_BG);
 
-    m_camera_switch_button = new wxStaticBitmap(m_panel_monitoring_title, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxSize(FromDIP(38), FromDIP(24)), 0);
-    m_camera_switch_button->SetMinSize(wxSize(FromDIP(38), FromDIP(24)));
-    m_camera_switch_button->SetBackgroundColour(STATUS_TITLE_BG);
-    m_camera_switch_button->SetBitmap(m_bitmap_switch_camera.bmp());
-    m_camera_switch_button->Bind(wxEVT_LEFT_DOWN, &StatusBasePanel::on_camera_switch_toggled, this);
-    m_camera_switch_button->Bind(wxEVT_RIGHT_DOWN, [this](auto& e) {
-        const std::string js_request_pip = R"(
-            document.querySelector('video').requestPictureInPicture();
-        )";
-        m_custom_camera_view->RunScript(js_request_pip);
-    });
-    m_camera_switch_button->Hide();
+    // m_camera_switch_button = new wxStaticBitmap(m_panel_monitoring_title, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxSize(FromDIP(38), FromDIP(24)), 0);
+    // m_camera_switch_button->SetMinSize(wxSize(FromDIP(38), FromDIP(24)));
+    // m_camera_switch_button->SetBackgroundColour(STATUS_TITLE_BG);
+    // m_camera_switch_button->SetBitmap(m_bitmap_switch_camera.bmp());
+    // m_camera_switch_button->Bind(wxEVT_RIGHT_DOWN, [this](auto& e) {
+    //     const std::string js_request_pip = R"(
+    //         document.querySelector('video').requestPictureInPicture();
+    //     )";
+    //     m_custom_camera_view->RunScript(js_request_pip);
+    // });
+    // m_camera_switch_button->Hide();
 
     m_bitmap_sdcard_img->SetToolTip(_L("Storage"));
     m_bitmap_timelapse_img->SetToolTip(_L("Timelapse"));
     m_bitmap_recording_img->SetToolTip(_L("Video"));
     m_bitmap_vcamera_img->SetToolTip(_L("Go Live"));
     m_setting_button->SetToolTip(_L("Camera Setting"));
-    m_camera_switch_button->SetToolTip(_L("Switch Camera View"));
+    // m_camera_switch_button->SetToolTip(_L("Switch Camera View"));
 
-    bSizer_monitoring_title->Add(m_camera_switch_button, 0, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
+    // bSizer_monitoring_title->Add(m_camera_switch_button, 0, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
     bSizer_monitoring_title->Add(m_bitmap_sdcard_img, 0, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
     bSizer_monitoring_title->Add(m_bitmap_timelapse_img, 0, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
     bSizer_monitoring_title->Add(m_bitmap_recording_img, 0, wxALIGN_CENTER_VERTICAL | wxALL, FromDIP(5));
@@ -1536,19 +1536,18 @@ wxBoxSizer *StatusBasePanel::create_monitoring_page()
     m_custom_camera_view = WebView::CreateWebView(this, wxEmptyString);
     m_custom_camera_view->EnableContextMenu(false);
     Bind(wxEVT_WEBVIEW_NAVIGATING, &StatusBasePanel::on_webview_navigating, this, m_custom_camera_view->GetId());
+    m_web_media_controller = std::make_unique<WebMediaController>(m_custom_camera_view);
 
     m_media_play_ctrl = new MediaPlayCtrl(this, m_media_ctrl, wxDefaultPosition, wxSize(-1, FromDIP(40)));
+    m_media_play_ctrl->SetWebMediaController(m_web_media_controller.get());
     m_custom_camera_view->Hide();
-    m_custom_camera_view->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, [this](wxWebViewEvent& evt) {
-        if (evt.GetString() == "leavepictureinpicture") {
-            // When leaving PiP, video gets paused in some cases and toggling play
-            // programmatically does not work.
-            m_custom_camera_view->Reload();
-        }
-        else if (evt.GetString() == "enterpictureinpicture") {
-            toggle_builtin_camera();
-        }
-    });
+    // m_custom_camera_view->Bind(wxEVT_WEBVIEW_SCRIPT_MESSAGE_RECEIVED, [this](wxWebViewEvent& evt) {
+    //     if (evt.GetString() == "leavepictureinpicture") {
+    //         // When leaving PiP, video gets paused in some cases and toggling play
+    //         // programmatically does not work.
+    //         m_custom_camera_view->Reload();
+    //     }
+    // });
 
     sizer->Add(m_media_ctrl, 1, wxEXPAND | wxALL, 0);
     sizer->Add(m_custom_camera_view, 1, wxEXPAND | wxALL, 0);
@@ -1558,10 +1557,6 @@ wxBoxSizer *StatusBasePanel::create_monitoring_page()
 //
 //    sizer->Add(media_ctrl_panel, 1, wxEXPAND | wxALL, 1);
 
-    if (wxGetApp().app_config->get("camera", "enable_custom_source") == "true") {
-        handle_camera_source_change();
-    }
-
     return sizer;
 }
 
@@ -2311,6 +2306,27 @@ void StatusPanel::update_camera_state(MachineObject* obj)
 {
     if (!obj) return;
 
+    auto agent = wxGetApp().getAgent();
+    const auto camera_mode = agent ? agent->get_camera_stream_mode() : CameraStreamMode::none;
+    const bool use_webview = camera_mode == CameraStreamMode::http_snapshot;
+    if (use_webview) {
+        //m_camera_switch_button->Hide();
+        if (!m_custom_camera_view->IsShown()) {
+            // why: do not reload the WebView URL per tick, or redirects can cause a reload loop.
+            // MediaPlayCtrl (via its WebMediaController) owns loading/playing the stream itself.
+            m_custom_camera_view->Show();
+            m_media_ctrl->Hide();
+        }
+    } else {
+        if (m_custom_camera_view->IsShown()) {
+            m_custom_camera_view->Hide();
+            // Stop the snapshot WebView before switching to native playback
+            // or leaving the camera mode.
+            m_media_play_ctrl->StopWebStream();
+        }
+        m_media_ctrl->Show();
+    }
+
     //sdcard
     auto sdcard_state = obj->GetStorage()->get_sdcard_state();
     if (m_last_sdcard != sdcard_state) {
@@ -2342,7 +2358,12 @@ void StatusPanel::update_camera_state(MachineObject* obj)
         m_last_recording = obj->is_recording() ? 1 : 0;
     }
 
-    if (!m_bitmap_recording_img->IsShown()) {
+    if (use_webview) {
+        if (m_bitmap_recording_img->IsShown()) {
+            m_bitmap_recording_img->Hide();
+            m_panel_monitoring_title->Layout();
+        }
+    } else if (!m_bitmap_recording_img->IsShown()) {
         m_bitmap_recording_img->Show();
         m_panel_monitoring_title->Layout();
     }
@@ -2399,6 +2420,8 @@ void StatusPanel::update_camera_state(MachineObject* obj)
         bool show_vcamera = m_media_play_ctrl->IsStreaming();
         m_camera_popup->update(show_vcamera);
     }
+
+    m_setting_button->Show(!use_webview);
 }
 
 StatusPanel::StatusPanel(wxWindow *parent, wxWindowID id, const wxPoint &pos, const wxSize &size, long style, const wxString &name)
@@ -3920,39 +3943,60 @@ void StatusPanel::update_cloud_subtask(MachineObject *obj)
         update_calib_bitmap();
         if (obj->slice_info) {
             m_request_url = wxString(obj->slice_info->thumbnail_url);
-            if (!m_request_url.IsEmpty()) {
-                wxImage                               img;
-                std::map<wxString, wxImage>::iterator it = img_list.find(m_request_url);
-                if (it != img_list.end()) {
-                    if (m_current_print_mode != PrintingTaskType::CALIBRATION  ||(m_calib_mode == CalibMode::Calib_Flow_Rate && m_calib_method == CalibrationMethod::CALI_METHOD_MANUAL)) {
-                        img = it->second;
-                        wxImage resize_img = img.Scale(m_project_task_panel->get_bitmap_thumbnail()->GetSize().x, m_project_task_panel->get_bitmap_thumbnail()->GetSize().y);
-                        m_project_task_panel->set_thumbnail_img(resize_img, "");
-                        m_project_task_panel->set_brightness_value(get_brightness_value(resize_img));
-                    }
-                    if (this->obj) {
-                        m_project_task_panel->set_plate_index(obj->m_plate_index);
-                    } else {
-                        m_project_task_panel->set_plate_index(-1);
-                    }
-                    task_thumbnail_state = ThumbnailState::TASK_THUMBNAIL;
-                    BOOST_LOG_TRIVIAL(trace) << "web_request: use cache image";
-                } else {
-                    web_request = wxWebSession::GetDefault().CreateRequest(this, m_request_url);
-                    BOOST_LOG_TRIVIAL(trace) << "monitor: start request thumbnail, url = " << m_request_url;
-                    web_request.Start();
-                    m_start_loading_thumbnail = false;
-                }
-            }
+            load_thumbnail_from_url(m_request_url, obj);
         }
     }
 }
 
+bool StatusPanel::load_thumbnail_from_url(const wxString &url, MachineObject *obj)
+{
+    if (url.IsEmpty())
+        return false;
+
+    wxImage                               img;
+    std::map<wxString, wxImage>::iterator it = img_list.find(url);
+    if (it != img_list.end()) {
+        if (m_current_print_mode != PrintingTaskType::CALIBRATION  ||(m_calib_mode == CalibMode::Calib_Flow_Rate && m_calib_method == CalibrationMethod::CALI_METHOD_MANUAL)) {
+            img = it->second;
+            wxImage resize_img = img.Scale(m_project_task_panel->get_bitmap_thumbnail()->GetSize().x, m_project_task_panel->get_bitmap_thumbnail()->GetSize().y);
+            m_project_task_panel->set_thumbnail_img(resize_img, "");
+            m_project_task_panel->set_brightness_value(get_brightness_value(resize_img));
+        }
+        if (this->obj) {
+            m_project_task_panel->set_plate_index(obj->m_plate_index);
+        } else {
+            m_project_task_panel->set_plate_index(-1);
+        }
+        task_thumbnail_state = ThumbnailState::TASK_THUMBNAIL;
+        BOOST_LOG_TRIVIAL(trace) << "web_request: use cache image";
+    } else {
+        m_request_url = url;
+        web_request = wxWebSession::GetDefault().CreateRequest(this, m_request_url);
+        BOOST_LOG_TRIVIAL(trace) << "monitor: start request thumbnail, url = " << m_request_url;
+        web_request.Start();
+        m_start_loading_thumbnail = false;
+    }
+    return true;
+}
+
 void StatusPanel::update_sdcard_subtask(MachineObject *obj)
 {
     if (!obj) return;
 
-    if (!m_load_sdcard_thumbnail) {
+    const wxString thumbnail_url = wxString(obj->m_agent_thumbnail_url);
+    if (!thumbnail_url.IsEmpty()) {
+        if (m_request_url != thumbnail_url || !m_load_sdcard_thumbnail) {
+            if (web_request.IsOk() && web_request.GetState() == wxWebRequest::State_Active)
+                web_request.Cancel();
+            update_calib_bitmap();
+            m_request_url = thumbnail_url;
+            load_thumbnail_from_url(thumbnail_url, obj);
+            m_load_sdcard_thumbnail = true;
+        }
+        return;
+    }
+
+    if (!m_load_sdcard_thumbnail || !m_request_url.IsEmpty()) {
         update_calib_bitmap();
         if (m_current_print_mode != PrintingTaskType::CALIBRATION) {
             m_project_task_panel->get_bitmap_thumbnail()->SetBitmap(m_thumbnail_sdcard.bmp());
@@ -3960,6 +4004,7 @@ void StatusPanel::update_sdcard_subtask(MachineObject *obj)
         }
         task_thumbnail_state = ThumbnailState::SDCARD_THUMBNAIL;
         m_load_sdcard_thumbnail = true;
+        m_request_url.clear();
     }
 }
 
@@ -4959,7 +5004,6 @@ void StatusPanel::on_camera_enter(wxMouseEvent& event)
             }
             sdcard_hint_dlg->on_show();
             });
-        m_camera_popup->Bind(EVT_CAM_SOURCE_CHANGE, &StatusPanel::on_camera_source_change, this);
         wxWindow* ctrl = (wxWindow*)event.GetEventObject();
         wxPoint   pos = ctrl->ClientToScreen(wxPoint(0, 0));
         wxSize        sz   = ctrl->GetSize();
@@ -4971,54 +5015,6 @@ void StatusPanel::on_camera_enter(wxMouseEvent& event)
     }
 }
 
-void StatusBasePanel::on_camera_source_change(wxCommandEvent& event)
-{
-    handle_camera_source_change();
-}
-
-void StatusBasePanel::handle_camera_source_change()
-{
-    const auto new_cam_url = wxGetApp().app_config->get("camera", "custom_source");
-    const auto enabled = wxGetApp().app_config->get("camera", "enable_custom_source") == "true";
-
-    if (enabled && !new_cam_url.empty()) {
-        m_custom_camera_view->LoadURL(new_cam_url);
-        toggle_custom_camera();
-        m_camera_switch_button->Show();
-    } else {
-        toggle_builtin_camera();
-        m_camera_switch_button->Hide();
-    }
-}
-
-void StatusBasePanel::toggle_builtin_camera()
-{
-    m_custom_camera_view->Hide();
-    m_media_ctrl->Show();
-    m_media_play_ctrl->Show();
-}
-
-void StatusBasePanel::toggle_custom_camera()
-{
-    const auto enabled = wxGetApp().app_config->get("camera", "enable_custom_source") == "true";
-
-    if (enabled) {
-        m_custom_camera_view->Show();
-        m_media_ctrl->Hide();
-        m_media_play_ctrl->Hide();
-    }
-}
-
-void StatusBasePanel::on_camera_switch_toggled(wxMouseEvent& event)
-{
-    const auto enabled = wxGetApp().app_config->get("camera", "enable_custom_source") == "true";
-    if (enabled && m_media_ctrl->IsShown()) {
-        toggle_custom_camera();
-    } else {
-        toggle_builtin_camera();
-    }
-}
-
 void StatusBasePanel::remove_controls()
 {
     const std::string js_cleanup_video_element = R"(
@@ -5171,6 +5167,11 @@ bool StatusPanel::is_stage_list_info_changed(MachineObject *obj)
 void StatusPanel::set_default()
 {
     BOOST_LOG_TRIVIAL(trace) << "status_panel: set_default";
+    if (m_custom_camera_view->IsShown()) {
+        m_custom_camera_view->Hide();
+        m_media_ctrl->Show();
+        m_media_play_ctrl->StopWebStream();
+    }
     obj                  = nullptr;
     last_subtask         = nullptr;
     last_tray_exist_bits = -1;

src/slic3r/GUI/StatusPanel.hpp

@@ -14,7 +14,9 @@
 #include <wx/sizer.h>
 #include <wx/gbsizer.h>
 #include <wx/webrequest.h>
+#include <memory>
 #include "MediaPlayCtrl.h"
+#include "WebMediaController.hpp"
 #include "AMSSetting.hpp"
 #include "Calibration.hpp"
 #include "CalibrationWizardPage.hpp"
@@ -439,7 +441,7 @@ protected:
     wxStaticBitmap *m_bitmap_sdcard_img;
     wxStaticBitmap *m_bitmap_static_use_time;
     wxStaticBitmap *m_bitmap_static_use_weight;
-    wxStaticBitmap* m_camera_switch_button;
+    // wxStaticBitmap* m_camera_switch_button;
 
 
     wxMediaCtrl3 *  m_media_ctrl;
@@ -461,6 +463,8 @@ protected:
     ScalableButton *m_button_abort;
     Button *        m_button_clean;
     wxWebView *     m_custom_camera_view{nullptr};
+    std::unique_ptr<WebMediaController> m_web_media_controller;
+
     wxSimplebook*   m_extruder_book;
     std::vector<ExtruderImage *> m_extruderImage;
 
@@ -576,13 +580,8 @@ protected:
     virtual void on_axis_ctrl_e_up_10(wxCommandEvent &event) { event.Skip(); }
     virtual void on_axis_ctrl_e_down_10(wxCommandEvent &event) { event.Skip(); }
     virtual void on_nozzle_selected(wxCommandEvent &event) { event.Skip(); }
-    void on_camera_source_change(wxCommandEvent& event);
-    void handle_camera_source_change();
     void remove_controls();
     void on_webview_navigating(wxWebViewEvent& evt);
-    void on_camera_switch_toggled(wxMouseEvent& event);
-    void toggle_custom_camera();
-    void toggle_builtin_camera();
 
 public:
     StatusBasePanel(wxWindow *      parent,
@@ -629,6 +628,7 @@ class StatusPanel : public StatusBasePanel
 {
 private:
     friend class MonitorPanel;
+    bool load_thumbnail_from_url(const wxString &url, MachineObject *obj);
 
 protected:
     std::shared_ptr<SliceInfoPopup> m_slice_info_popup;

src/slic3r/GUI/SyncAmsInfoDialog.cpp

@@ -1863,7 +1863,6 @@ bool SyncAmsInfoDialog::is_blocking_printing(MachineObject *obj_)
 {
     DeviceManager *dev = Slic3r::GUI::wxGetApp().getDeviceManager();
     if (!dev) return true;
-    auto        target_model = obj_->printer_type;
     std::string source_model = "";
 
     if (m_print_type == PrintFromType::FROM_NORMAL) {
@@ -1874,13 +1873,7 @@ bool SyncAmsInfoDialog::is_blocking_printing(MachineObject *obj_)
         if (m_required_data_plate_data_list.size() > 0) { source_model = m_required_data_plate_data_list[m_print_plate_idx]->printer_model_id; }
     }
 
-    if (source_model != target_model) {
-        std::vector<std::string>      compatible_machine = obj_->get_compatible_machine();
-        vector<std::string>::iterator it                 = find(compatible_machine.begin(), compatible_machine.end(), source_model);
-        if (it == compatible_machine.end()) { return true; }
-    }
-
-    return false;
+    return !DevPrinterConfigUtil::is_printer_model_compatible(source_model, *obj_);
 }
 
 bool SyncAmsInfoDialog::is_same_nozzle_type(std::string &filament_type, NozzleType &tag_nozzle_type)
@@ -1930,7 +1923,13 @@ bool SyncAmsInfoDialog::is_same_printer_model()
     if (obj_ == nullptr) { return result; }
 
     PresetBundle *preset_bundle = wxGetApp().preset_bundle;
-    if (preset_bundle && preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) != obj_->printer_type) {
+    const std::string source_model = preset_bundle ? preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) : std::string();
+    if (DevPrinterConfigUtil::is_optional_printer_model_id(source_model) ||
+        DevPrinterConfigUtil::is_optional_printer_model_id(obj_->printer_type)) {
+        return true;
+    }
+
+    if (preset_bundle && source_model != obj_->printer_type) {
         if ((obj_->is_support_upgrade_kit && obj_->installed_upgrade_kit) && (preset_bundle->printers.get_edited_preset().get_printer_type(preset_bundle) == "C12")) {
             return true;
         }
@@ -2131,7 +2130,7 @@ void SyncAmsInfoDialog::update_user_printer()
     std::map<std::string, MachineObject *> option_list;
 
     // user machine list
-    option_list = dev->get_my_machine_list();
+    option_list = dev->get_my_machine_list(dev->get_current_printer_agent_id());
 
     // same machine only appear once
     for (auto it = option_list.begin(); it != option_list.end(); it++) {
@@ -3206,6 +3205,7 @@ SyncAmsInfoDialog::~SyncAmsInfoDialog() {
 void SyncAmsInfoDialog::set_info(SyncInfo &info)
 {
     m_input_info = info;
+    reinit_dialog();
 }
 
 void SyncAmsInfoDialog::update_lan_machine_list()

src/slic3r/GUI/Tab.cpp

@@ -3026,8 +3026,6 @@ void TabPrint::build()
         optgroup = page->new_optgroup(L("Advanced"), L"advanced");
         optgroup->append_single_option_line("interlocking_beam", "multimaterial_settings_advanced#interlocking-beam");
         optgroup->append_single_option_line("toolchange_ordering", "multimaterial_settings_advanced#toolchange-ordering");
-        optgroup->append_single_option_line("toolchange_cyclic_order", "multimaterial_settings_advanced#toolchange-order");
-        optgroup->append_single_option_line("toolchange_cyclic_first_layer", "multimaterial_settings_advanced#toolchange-order");
         optgroup->append_single_option_line("interface_shells", "multimaterial_settings_advanced#interface-shells");
         optgroup->append_single_option_line("mmu_segmented_region_max_width", "multimaterial_settings_advanced#maximum-width-of-segmented-region");
         optgroup->append_single_option_line("mmu_segmented_region_interlocking_depth", "multimaterial_settings_advanced#interlocking-depth-of-segmented-region");

src/slic3r/GUI/WebMediaController.cpp

@@ -0,0 +1,76 @@
+#include "WebMediaController.hpp"
+
+#include <wx/webview.h>
+
+namespace Slic3r { namespace GUI {
+
+WebMediaController::WebMediaController(wxWebView* webview) : m_webview(webview)
+{
+    if (!m_webview)
+        return;
+
+    m_webview->SetBackgroundColour(*wxBLACK);
+    m_webview->SetPage("<html><head><style>html,body{margin:0;height:100%;background:#000;}</style></head><body></body></html>", "");
+}
+
+void WebMediaController::Load(wxURI url) { Load(url, CameraStreamMode::http); }
+
+void WebMediaController::Load(wxURI url, CameraStreamMode mode)
+{
+    m_url         = url.BuildURI().ToStdString();
+    m_stream_mode = mode;
+}
+
+void WebMediaController::Play()
+{
+    if (!m_webview)
+        return;
+
+    wxString url  = wxString::FromUTF8(m_url);
+    wxString html = "<html><head><style>"
+                    "html,body{margin:0;height:100%;background:#000;overflow:hidden;}"
+                    "img{width:100%;height:100%;object-fit:contain;display:block;}"
+                    "</style></head><body><img id=\"camera-frame\"";
+    if (m_stream_mode == CameraStreamMode::http_snapshot) {
+        html += " data-camera-url=\"" + url +
+                "\"><script>"
+                "const cameraFrame=document.getElementById('camera-frame');"
+                "const cameraUrl=cameraFrame.dataset.cameraUrl;"
+                "let cameraFrameLoading=false;"
+                "function refreshCameraFrame(){"
+                "if(cameraFrameLoading)return;"
+                "cameraFrameLoading=true;"
+                "const nextFrame=new Image();"
+                "nextFrame.onload=function(){cameraFrame.src=nextFrame.src;cameraFrameLoading=false;};"
+                "nextFrame.onerror=function(){cameraFrameLoading=false;};"
+                "nextFrame.src=cameraUrl+(cameraUrl.indexOf('?')>=0?'&':'?')+'_orca_frame='+Date.now();"
+                "}"
+                "let cameraRefreshInterval=null;"
+                "function stopCameraRefresh(){"
+                "if(cameraRefreshInterval!==null){"
+                "clearInterval(cameraRefreshInterval);"
+                "cameraRefreshInterval=null;"
+                "}"
+                "}"
+                "refreshCameraFrame();"
+                "cameraRefreshInterval = setInterval(refreshCameraFrame,200);"
+                "</script></body></html>";
+        m_webview->SetPage(html, url);
+    } else {
+        // Load MJPEG streams as the top-level document.  Some embedded WebView
+        // backends buffer a multipart stream when it is used as an <img> resource,
+        // which introduces noticeable live-view latency.
+        m_webview->LoadURL(url);
+    }
+}
+
+void WebMediaController::Stop()
+{
+    if (m_webview) {
+        m_webview->RunScript("if(typeof stopCameraRefresh==='function') stopCameraRefresh();");
+        m_webview->Stop();
+    }
+    m_url.clear();
+}
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/WebMediaController.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <slic3r/GUI/IMediaController.hpp>
+
+#include <string>
+
+class wxWebView;
+
+namespace Slic3r { namespace GUI {
+
+class WebMediaController : public IMediaController
+{
+public:
+    explicit WebMediaController(wxWebView* webview);
+
+    void Load(wxURI url) override;
+
+    void Load(wxURI url, CameraStreamMode mode) override;
+
+    void Play() override;
+
+    void Stop() override;
+
+private:
+    wxWebView* m_webview;
+    std::string m_url;
+    CameraStreamMode m_stream_mode = CameraStreamMode::http;
+};
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/WebRtcMediaController.cpp

@@ -0,0 +1,395 @@
+#include "WebRtcMediaController.hpp"
+
+#include <rtc/common.hpp>
+#include <rtc/rtc.hpp>
+
+#include <mutex>
+#include <wx/mstream.h>
+
+#include <boost/log/trivial.hpp>
+
+namespace {
+void init_rtc_logger_once()
+{
+    static std::once_flag flag;
+    std::call_once(flag, [] {
+        rtc::InitLogger(rtc::LogLevel::Warning, [](rtc::LogLevel level, std::string message) {
+            BOOST_LOG_TRIVIAL(trace) << "[rtc:" << static_cast<int>(level) << "] " << message;
+        });
+    });
+}
+} // namespace
+
+namespace Slic3r { namespace GUI {
+
+WebRtcMediaController::WebRtcMediaController(std::function<void(const wxImage&, wxSize)> frame_sink,
+                                             std::function<void(Status)> on_status)
+    : m_frame_sink(std::move(frame_sink))
+    , m_on_status(std::move(on_status))
+{
+}
+
+WebRtcMediaController::~WebRtcMediaController()
+{
+    StopSession();
+}
+
+void WebRtcMediaController::report(Status status)
+{
+    status.epoch = m_epoch.load();
+    BOOST_LOG_TRIVIAL(info) << "WebRTC: report kind=" << static_cast<int>(status.kind)
+                            << " code=" << static_cast<int>(status.code) << " epoch=" << status.epoch;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (status.kind == Status::Connecting)
+            m_state = static_cast<wxMediaState>(4);
+        else if (status.kind == Status::Playing)
+            m_state = wxMEDIASTATE_PLAYING;
+        else
+            m_state = static_cast<wxMediaState>(3);
+    }
+    if (m_on_status)
+        m_on_status(status);
+}
+
+void WebRtcMediaController::StartSession(std::unique_ptr<ICameraSignalingChannel> channel)
+{
+    // Tear down any previous attempt WITHOUT notifying: the Stopped that would
+    // otherwise be delivered (async, via CallAfter) races the new attempt's
+    // Connecting and makes the consumer cancel a session that is mid-connect.
+    teardown(false);
+    if (!channel)
+        return;
+
+    m_epoch.fetch_add(1);
+    m_alive.store(true);
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_signaling = std::move(channel);
+        m_jpeg_queue.clear();
+        m_pending_candidates.clear();
+        m_remote_description_set = false;
+        m_video_size = wxDefaultSize;
+        m_has_frame = false;
+        m_last_frame_time = {};
+    }
+
+    ICameraSignalingChannel* signaling = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        signaling = m_signaling.get();
+    }
+    signaling->on_ready = [this](std::vector<CameraIceServer> servers) {
+        if (m_alive.load())
+            on_ready(std::move(servers));
+    };
+    signaling->on_answer = [this](std::string sdp) {
+        if (m_alive.load())
+            on_answer(std::move(sdp));
+    };
+    signaling->on_ice = [this](std::string candidate, std::string mid) {
+        if (m_alive.load())
+            on_ice(std::move(candidate), std::move(mid));
+    };
+    signaling->on_unavailable = [this](CameraUnavailableReason reason, std::string detail) {
+        if (m_alive.load())
+            on_unavailable(reason, std::move(detail));
+    };
+
+    m_decode_thread = std::thread([this] { decode_loop(); });
+    report({Status::Connecting});
+    signaling->open();
+}
+
+void WebRtcMediaController::StopSession()
+{
+    teardown(true);
+}
+
+void WebRtcMediaController::teardown(bool notify)
+{
+    const bool was_alive = m_alive.exchange(false);
+    if (!was_alive && !m_decode_thread.joinable())
+        return;
+
+    m_cond.notify_all();
+    std::unique_ptr<ICameraSignalingChannel> signaling;
+    std::shared_ptr<rtc::PeerConnection> peer_connection;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        signaling = std::move(m_signaling);
+        peer_connection = std::move(m_peer_connection);
+        m_data_channel.reset();
+    }
+    if (signaling)
+        signaling->close();
+    if (peer_connection)
+        peer_connection->close();
+    if (m_decode_thread.joinable())
+        m_decode_thread.join();
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_jpeg_queue.clear();
+    }
+    if (was_alive && notify)
+        report({Status::Stopped});
+}
+
+wxMediaState WebRtcMediaController::GetState()
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    return m_state;
+}
+
+wxSize WebRtcMediaController::GetVideoSize() const
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    return m_video_size;
+}
+
+void WebRtcMediaController::bind_data_channel(const std::shared_ptr<rtc::DataChannel>& dc)
+{
+    const std::string label = dc->label();
+    dc->onOpen([label] { BOOST_LOG_TRIVIAL(info) << "WebRTC: data channel '" << label << "' open"; });
+    dc->onClosed([label] { BOOST_LOG_TRIVIAL(info) << "WebRTC: data channel '" << label << "' closed"; });
+    dc->onError([label](std::string e) {
+        BOOST_LOG_TRIVIAL(warning) << "WebRTC: data channel '" << label << "' error: " << e;
+    });
+    dc->onMessage(
+        [this](rtc::binary data) {
+            if (m_alive.load())
+                enqueue_jpeg(std::vector<std::byte>(data.begin(), data.end()));
+        },
+        [](rtc::string) {});
+}
+
+void WebRtcMediaController::on_ready(std::vector<CameraIceServer> servers)
+{
+    init_rtc_logger_once();
+    rtc::Configuration configuration;
+    // Allow complete-JPEG DataChannel messages up to 1 MiB. This value is
+    // advertised in SDP and becomes the upper bound for frames OrcaSonar can
+    // send to OrcaSlicer.
+    configuration.maxMessageSize = 1024 * 1024;
+    for (const CameraIceServer& server : servers) {
+        try {
+            rtc::IceServer ice_server(server.urls);
+            ice_server.username = server.username;
+            ice_server.password = server.credential;
+            configuration.iceServers.emplace_back(std::move(ice_server));
+        } catch (const std::exception& e) {
+            BOOST_LOG_TRIVIAL(warning) << "WebRTC: invalid ICE server: " << e.what();
+        }
+    }
+
+    BOOST_LOG_TRIVIAL(info) << "WebRTC: creating peer connection with " << configuration.iceServers.size() << " ice servers";
+    auto peer_connection = std::make_shared<rtc::PeerConnection>(std::move(configuration));
+    peer_connection->onLocalDescription([this](rtc::Description description) {
+        if (!m_alive.load())
+            return;
+        const std::string sdp(description);
+        BOOST_LOG_TRIVIAL(info) << "WebRTC: local description ready (" << description.typeString()
+                                << "), OFFER SDP:\n" << sdp;
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (m_signaling)
+            m_signaling->send_offer(sdp);
+    });
+    peer_connection->onLocalCandidate([this](rtc::Candidate candidate) {
+        if (!m_alive.load())
+            return;
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (m_signaling)
+            m_signaling->send_ice(std::string(candidate), candidate.mid());
+    });
+    peer_connection->onStateChange([this](rtc::PeerConnection::State state) {
+        BOOST_LOG_TRIVIAL(info) << "WebRTC: peer state -> " << static_cast<int>(state);
+        if (!m_alive.load())
+            return;
+        if (state == rtc::PeerConnection::State::Failed || state == rtc::PeerConnection::State::Disconnected)
+            report({Status::Failed, Status::ICE_FAILED});
+    });
+    peer_connection->onGatheringStateChange([](rtc::PeerConnection::GatheringState state) {
+        BOOST_LOG_TRIVIAL(info) << "WebRTC: gathering state -> " << static_cast<int>(state);
+    });
+
+    // Accept a DataChannel opened by the remote peer (OrcaSonar may create the
+    // "camera" channel from its side rather than answering the one we offer).
+    peer_connection->onDataChannel([this](std::shared_ptr<rtc::DataChannel> dc) {
+        BOOST_LOG_TRIVIAL(info) << "WebRTC: remote opened data channel '" << dc->label() << "'";
+        bind_data_channel(dc);
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_data_channel = std::move(dc);
+    });
+
+    rtc::DataChannelInit init;
+    init.reliability.unordered = true;
+    // init.reliability.maxPacketLifeTime = std::chrono::milliseconds(350);
+    // Request one complete JPEG frame per DataChannel message. OrcaSonar
+    // keeps the legacy chunked protocol for clients that omit this property.
+    init.protocol = "orca-jpeg";
+    auto data_channel = peer_connection->createDataChannel("camera", init);
+    if (data_channel)
+        bind_data_channel(data_channel);
+
+    // Camera media is carried as one complete JPEG per DataChannel message;
+    // no RTP video track or application-level framing is required.
+
+    std::shared_ptr<rtc::PeerConnection> peer_for_description;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (!m_alive.load())
+            return;
+        m_peer_connection = std::move(peer_connection);
+        peer_for_description = m_peer_connection;
+        m_data_channel = std::move(data_channel);
+    }
+    if (peer_for_description)
+        peer_for_description->setLocalDescription();
+}
+
+void WebRtcMediaController::on_answer(std::string sdp)
+{
+    std::shared_ptr<rtc::PeerConnection> peer_connection;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        peer_connection = m_peer_connection;
+    }
+    BOOST_LOG_TRIVIAL(info) << "WebRTC: applying remote answer (" << sdp.size() << " bytes), ANSWER SDP:\n" << sdp;
+    if (!peer_connection)
+        return;
+    try {
+        peer_connection->setRemoteDescription(rtc::Description(sdp, "answer"));
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "WebRTC: setRemoteDescription failed: " << e.what();
+        report({Status::Failed, Status::ICE_FAILED});
+        return;
+    }
+
+    // Flush any remote candidates that arrived before the answer.
+    std::vector<std::pair<std::string, std::string>> pending;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_remote_description_set = true;
+        pending.swap(m_pending_candidates);
+    }
+    BOOST_LOG_TRIVIAL(info) << "WebRTC: remote description set, flushing " << pending.size()
+                            << " buffered candidate(s)";
+    for (const auto& c : pending) {
+        try {
+            peer_connection->addRemoteCandidate(rtc::Candidate(c.first, c.second));
+        } catch (const std::exception& e) {
+            BOOST_LOG_TRIVIAL(warning) << "WebRTC: addRemoteCandidate (buffered) failed: " << e.what();
+        }
+    }
+}
+
+void WebRtcMediaController::on_ice(std::string candidate, std::string mid)
+{
+    std::shared_ptr<rtc::PeerConnection> peer_connection;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (!m_remote_description_set) {
+            m_pending_candidates.emplace_back(std::move(candidate), std::move(mid));
+            return;
+        }
+        peer_connection = m_peer_connection;
+    }
+    if (!peer_connection)
+        return;
+    try {
+        peer_connection->addRemoteCandidate(rtc::Candidate(candidate, mid));
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "WebRTC: addRemoteCandidate failed: " << e.what();
+    }
+}
+
+void WebRtcMediaController::on_unavailable(CameraUnavailableReason reason, std::string detail)
+{
+    BOOST_LOG_TRIVIAL(warning) << "WebRTC camera unavailable: " << detail;
+    Status::Code code = Status::UNAVAILABLE_ERROR;
+    if (reason == CameraUnavailableReason::Busy)
+        code = Status::UNAVAILABLE_BUSY;
+    else if (reason == CameraUnavailableReason::Disabled)
+        code = Status::UNAVAILABLE_DISABLED;
+    else if (reason == CameraUnavailableReason::Closed)
+        code = Status::SIGNALING_CLOSED;
+    report({Status::Failed, code});
+}
+
+void WebRtcMediaController::enqueue_jpeg(std::vector<std::byte> jpeg)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if (m_jpeg_queue.size() >= 4)
+        m_jpeg_queue.pop_front();
+    m_jpeg_queue.emplace_back(std::move(jpeg));
+    m_cond.notify_one();
+}
+
+void WebRtcMediaController::deliver_jpeg(std::vector<std::byte> jpeg)
+{
+    const auto now = std::chrono::steady_clock::now();
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (m_last_frame_time != std::chrono::steady_clock::time_point{} &&
+            now - m_last_frame_time < std::chrono::milliseconds(33))
+            return;
+        m_last_frame_time = now;
+    }
+    wxMemoryInputStream stream(jpeg.data(), jpeg.size());
+    wxImage image;
+    if (!image.LoadFile(stream, wxBITMAP_TYPE_JPEG)) {
+        report({Status::Failed, Status::DECODE_ERROR});
+        return;
+    }
+    bool first_frame = false;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_video_size = image.GetSize();
+        first_frame = !m_has_frame;
+        m_has_frame = true;
+    }
+    if (m_frame_sink)
+        m_frame_sink(image, image.GetSize());
+    if (first_frame)
+        report({Status::Playing});
+}
+
+void WebRtcMediaController::decode_loop()
+{
+    int stall_polls = 0;
+    std::unique_lock<std::mutex> lock(m_mutex);
+    while (m_alive.load()) {
+        const bool woke = m_cond.wait_for(lock, std::chrono::seconds(2), [this] {
+            return !m_alive.load() || !m_jpeg_queue.empty();
+        });
+        if (!m_alive.load())
+            break;
+        if (!woke && !m_has_frame) {
+            const int pc_state = m_peer_connection ? static_cast<int>(m_peer_connection->state()) : -1;
+            std::string dc = "none";
+            if (m_data_channel)
+                dc = "label='" + m_data_channel->label() + "' open=" +
+                     (m_data_channel->isOpen() ? "1" : "0");
+            lock.unlock();
+            BOOST_LOG_TRIVIAL(info) << "WebRTC: waiting for frames; peer_state=" << pc_state
+                                    << " data_channel=" << dc;
+            if (++stall_polls >= 8) { // ~16s connected with no frame -> give up so the UI can retry
+                report({Status::Failed, Status::TIMEOUT});
+                lock.lock();
+                break;
+            }
+            lock.lock();
+            continue;
+        }
+        stall_polls = 0;
+        if (!m_jpeg_queue.empty()) {
+            auto jpeg = std::move(m_jpeg_queue.front());
+            m_jpeg_queue.pop_front();
+            lock.unlock();
+            deliver_jpeg(std::move(jpeg));
+            lock.lock();
+        }
+    }
+}
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/WebRtcMediaController.hpp

@@ -0,0 +1,92 @@
+#pragma once
+
+#include "IMediaController.hpp"
+
+#include <wx/image.h>
+
+#include <atomic>
+#include <chrono>
+#include <cstddef>
+#include <condition_variable>
+#include <cstdint>
+#include <deque>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+namespace rtc {
+class DataChannel;
+class PeerConnection;
+}
+
+namespace Slic3r { namespace GUI {
+
+class WebRtcMediaController : public IMediaController {
+public:
+    struct Status {
+        enum Kind { Connecting, Playing, Stopped, Failed } kind = Stopped;
+        enum Code {
+            ICE_FAILED,
+            SIGNALING_CLOSED,
+            UNAVAILABLE_BUSY,
+            UNAVAILABLE_ERROR,
+            UNAVAILABLE_DISABLED,
+            DECODE_ERROR,
+            TIMEOUT,
+        } code = ICE_FAILED;
+        // Identifies the StartSession attempt this status belongs to, so the
+        // consumer can drop CallAfter-queued events from a superseded attempt.
+        std::uint64_t epoch = 0;
+    };
+
+    WebRtcMediaController(std::function<void(const wxImage&, wxSize)> frame_sink,
+                          std::function<void(Status)> on_status);
+    ~WebRtcMediaController() override;
+
+    void StartSession(std::unique_ptr<ICameraSignalingChannel> channel) override;
+    void StopSession() override;
+    std::uint64_t epoch() const { return m_epoch.load(); }
+    bool is_active() const { return m_alive.load(); }
+
+    void Load(wxURI) override {}
+    void Play() override {}
+    void Stop() override { StopSession(); }
+    wxMediaState GetState() override;
+    wxSize GetVideoSize() const override;
+
+private:
+    void teardown(bool notify);
+    void report(Status status);
+    void bind_data_channel(const std::shared_ptr<rtc::DataChannel>& dc);
+    void on_ready(std::vector<CameraIceServer> servers);
+    void on_answer(std::string sdp);
+    void on_ice(std::string candidate, std::string mid);
+    void on_unavailable(CameraUnavailableReason reason, std::string detail);
+    void decode_loop();
+    void enqueue_jpeg(std::vector<std::byte> jpeg);
+    void deliver_jpeg(std::vector<std::byte> jpeg);
+
+    mutable std::mutex m_mutex;
+    std::condition_variable m_cond;
+    std::deque<std::vector<std::byte>> m_jpeg_queue;
+    // Remote candidates can arrive before the answer; libdatachannel rejects
+    // addRemoteCandidate until a remote description is set, so buffer them.
+    std::vector<std::pair<std::string, std::string>> m_pending_candidates;
+    bool m_remote_description_set = false;
+    std::unique_ptr<ICameraSignalingChannel> m_signaling;
+    std::shared_ptr<rtc::PeerConnection> m_peer_connection;
+    std::shared_ptr<rtc::DataChannel> m_data_channel;
+    std::thread m_decode_thread;
+    std::atomic<bool> m_alive{false};
+    std::atomic<std::uint64_t> m_epoch{0};
+    wxMediaState m_state = static_cast<wxMediaState>(3);
+    wxSize m_video_size = wxDefaultSize;
+    std::function<void(const wxImage&, wxSize)> m_frame_sink;
+    std::function<void(Status)> m_on_status;
+    bool m_has_frame = false;
+    std::chrono::steady_clock::time_point m_last_frame_time{};
+};
+
+}} // namespace Slic3r::GUI

src/slic3r/GUI/wxMediaCtrl3.cpp

@@ -4,6 +4,14 @@
 #include "libslic3r/Utils.hpp"
 #include <boost/log/trivial.hpp>
 #include <wx/dcclient.h>
+#include <cstdarg>
+#include <cstdlib>
+#include <cstring>
+#include <mutex>
+extern "C" {
+#include <libavformat/avformat.h>
+#include <libavutil/log.h>
+}
 #ifdef __WIN32__
 #include <versionhelpers.h>
 #include <wx/msw/registry.h>
@@ -43,9 +51,13 @@ wxMediaCtrl3::~wxMediaCtrl3()
     m_thread.join();
 }
 
+static void adjust_frame_size(wxSize& frame, wxSize const& video, wxSize const& window);
+
 void wxMediaCtrl3::Load(wxURI url)
 {
     std::unique_lock<std::mutex> lk(m_mutex);
+    if (m_external)
+        return;
     m_video_size = wxDefaultSize;
     m_error = 0;
     m_url.reset(new wxURI(url));
@@ -55,6 +67,8 @@ void wxMediaCtrl3::Load(wxURI url)
 void wxMediaCtrl3::Play()
 {
     std::unique_lock<std::mutex> lk(m_mutex);
+    if (m_external)
+        return;
     if (m_state != wxMEDIASTATE_PLAYING) {
         m_state = wxMEDIASTATE_PLAYING;
         wxMediaEvent event(wxEVT_MEDIA_STATECHANGED);
@@ -74,6 +88,62 @@ void wxMediaCtrl3::Stop()
     Refresh();
 }
 
+void wxMediaCtrl3::SetExternalFrame(const wxImage& frame, wxSize videoSize)
+{
+    if (!frame.IsOk())
+        return;
+    {
+        std::unique_lock<std::mutex> lk(m_mutex);
+        if (!m_external)
+            return;
+        m_frame = frame;
+        m_video_size = videoSize.IsFullySpecified() ? videoSize : frame.GetSize();
+        adjust_frame_size(m_frame_size, m_video_size, GetSize());
+    }
+    CallAfter([this] { Refresh(); });
+}
+
+#ifdef _WIN32
+void wxMediaCtrl3::SetExternalFrame(const wxBitmap& frame, wxSize videoSize)
+{
+    if (!frame.IsOk())
+        return;
+    {
+        std::unique_lock<std::mutex> lk(m_mutex);
+        if (!m_external)
+            return;
+        m_frame = frame;
+        m_video_size = videoSize.IsFullySpecified() ? videoSize : frame.GetSize();
+        adjust_frame_size(m_frame_size, m_video_size, GetSize());
+    }
+    CallAfter([this] { Refresh(); });
+}
+#endif
+
+void wxMediaCtrl3::BeginExternalStream()
+{
+    std::unique_lock<std::mutex> lk(m_mutex);
+    m_external = true;
+    m_url.reset();
+    m_active_url.reset();
+    m_video_size = wxDefaultSize;
+    m_frame = wxImage(m_idle_image);
+    m_cond.notify_all();
+    Refresh();
+}
+
+void wxMediaCtrl3::EndExternalStream()
+{
+    std::unique_lock<std::mutex> lk(m_mutex);
+    m_external = false;
+    m_url.reset();
+    m_active_url.reset();
+    m_video_size = wxDefaultSize;
+    m_frame = wxImage(m_idle_image);
+    m_cond.notify_all();
+    Refresh();
+}
+
 void wxMediaCtrl3::SetIdleImage(wxString const &image)
 {
     if (m_idle_image == image)
@@ -185,6 +255,210 @@ void wxMediaCtrl3::bambu_log(void *ctx, int level, tchar const *msg2)
     BOOST_LOG_TRIVIAL(info) << msg.ToUTF8().data();
 }
 
+// FFmpeg's own diagnostics (HTTP status, "Invalid data found", demuxer choice,
+// missing stream dimensions, ...) are otherwise swallowed: a failed camera open
+// only surfaces as wxMediaCtrl3's generic error code, which MediaPlayCtrl maps to
+// the misleading "Player is malfunctioning" string. Forward them to the Orca log
+// instead. Verbosity defaults to AV_LOG_VERBOSE and can be raised at runtime with
+// ORCA_FFMPEG_LOG_LEVEL=debug|trace|... (or lowered to warning/error/quiet).
+static int ffmpeg_log_level_from_env()
+{
+    const char *env = std::getenv("ORCA_FFMPEG_LOG_LEVEL");
+    if (env == nullptr || *env == '\0')
+        return AV_LOG_VERBOSE;
+    const wxString v = wxString(env).Lower();
+    if (v == "quiet")   return AV_LOG_QUIET;
+    if (v == "panic")   return AV_LOG_PANIC;
+    if (v == "fatal")   return AV_LOG_FATAL;
+    if (v == "error")   return AV_LOG_ERROR;
+    if (v == "warning") return AV_LOG_WARNING;
+    if (v == "info")    return AV_LOG_INFO;
+    if (v == "verbose") return AV_LOG_VERBOSE;
+    if (v == "debug")   return AV_LOG_DEBUG;
+    if (v == "trace")   return AV_LOG_TRACE;
+    return AV_LOG_VERBOSE;
+}
+
+static void ffmpeg_log_callback(void *avcl, int level, const char *fmt, va_list vl)
+{
+    if (level > av_log_get_level())
+        return;
+    thread_local int print_prefix = 1;
+    char line[1024];
+    av_log_format_line2(avcl, level, fmt, vl, line, (int) sizeof(line), &print_prefix);
+    size_t len = std::strlen(line);
+    while (len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r' || line[len - 1] == ' '))
+        line[--len] = '\0';
+    if (len == 0)
+        return;
+    if (level <= AV_LOG_ERROR)
+        BOOST_LOG_TRIVIAL(error) << "ffmpeg: " << line;
+    else if (level <= AV_LOG_WARNING)
+        BOOST_LOG_TRIVIAL(warning) << "ffmpeg: " << line;
+    else if (level <= AV_LOG_INFO)
+        BOOST_LOG_TRIVIAL(info) << "ffmpeg: " << line;
+    else
+        BOOST_LOG_TRIVIAL(debug) << "ffmpeg: " << line;
+}
+
+static void install_ffmpeg_logger()
+{
+    av_log_set_level(ffmpeg_log_level_from_env());
+    av_log_set_callback(&ffmpeg_log_callback);
+}
+
+int wxMediaCtrl3::ffmpeg_interrupt_callback(void *opaque)
+{
+    auto *ctrl = static_cast<wxMediaCtrl3 *>(opaque);
+    std::lock_guard<std::mutex> lock(ctrl->m_mutex);
+    return ctrl->m_url != ctrl->m_active_url;
+}
+
+int wxMediaCtrl3::PlayFfmpeg(std::shared_ptr<wxURI> const &url, std::unique_lock<std::mutex> &lock)
+{
+    static std::once_flag logger_once;
+    std::call_once(logger_once, install_ffmpeg_logger);
+
+    if (avformat_network_init() < 0)
+        return 2;
+
+    AVFormatContext *format_context = avformat_alloc_context();
+    if (!format_context) {
+        avformat_network_deinit();
+        return 2;
+    }
+
+    format_context->interrupt_callback = {&wxMediaCtrl3::ffmpeg_interrupt_callback, this};
+    format_context->flags |= AVFMT_FLAG_NOBUFFER;
+    format_context->max_delay = 0;
+    m_active_url = url;
+
+    auto finish = [&](int error) {
+        lock.unlock();
+        avformat_close_input(&format_context);
+        avformat_network_deinit();
+        lock.lock();
+        m_active_url.reset();
+        return error;
+    };
+
+    const std::string uri = url->BuildURI().ToUTF8().data();
+    const wxString scheme = url->GetScheme();
+    const bool http_stream = scheme.CmpNoCase("http") == 0 || scheme.CmpNoCase("https") == 0;
+    AVDictionary *options = nullptr;
+    if (http_stream) {
+        // Live multipart MJPEG. fflags=nobuffer / AVFMT_FLAG_NOBUFFER / max_delay=0
+        // (set above) are the low-latency levers - they disable the demuxer
+        // read-ahead queue. probesize / analyzeduration only bound the one-off
+        // avformat_find_stream_info() at open; a 32-byte budget returned before a
+        // whole JPEG frame was seen, so width/height came back unset and the open
+        // was rejected. Give it room to identify one frame (a startup cost only).
+        // rw_timeout / timeout bound a wedged connect or read so a stale stream
+        // fails fast and is retried, instead of the reader thread hanging.
+        // avioflags=direct is deliberately NOT set: unbuffered reads make the
+        // mpjpeg demuxer emit "Packet corrupt" and bail on any short read across
+        // a multipart boundary.
+        av_dict_set(&options, "fflags", "nobuffer", 0);
+        av_dict_set(&options, "probesize", "5000000", 0);
+        av_dict_set(&options, "analyzeduration", "1000000", 0);
+        av_dict_set(&options, "rw_timeout", "5000000", 0);
+        av_dict_set(&options, "timeout", "5000000", 0);
+    } else {
+        av_dict_set(&options, "rtsp_transport", "tcp", 0);
+    }
+    lock.unlock();
+    int error = avformat_open_input(&format_context, uri.c_str(), nullptr, &options);
+    av_dict_free(&options);
+    lock.lock();
+    if (error < 0)
+        return finish(2);
+
+    lock.unlock();
+    error = avformat_find_stream_info(format_context, nullptr);
+    lock.lock();
+    if (error < 0)
+        return finish(2);
+
+    const int video_stream = av_find_best_stream(format_context, AVMEDIA_TYPE_VIDEO, -1, -1, nullptr, 0);
+    if (video_stream < 0)
+        return finish(2);
+
+    AVVideoDecoder decoder;
+    if (decoder.open(*format_context->streams[video_stream]->codecpar) < 0)
+        return finish(2);
+
+    // Prefer the dimensions the container reported. A small probe budget, or a
+    // camera that doesn't announce a size up front, can leave these unset - in
+    // that case fill them in from the first frame that decodes (below) rather
+    // than failing the open outright.
+    auto apply_video_size = [&](wxSize size) {
+        if (!size.IsFullySpecified() || size.x <= 0 || size.y <= 0)
+            return false;
+        m_video_size = size;
+        adjust_frame_size(m_frame_size, m_video_size, GetSize());
+        NotifyStopped();
+        return true;
+    };
+    bool have_size = apply_video_size({format_context->streams[video_stream]->codecpar->width,
+                                      format_context->streams[video_stream]->codecpar->height});
+    int size_probe_frames = 0; // frames spent still waiting for a usable size
+
+    AVPacket *packet = av_packet_alloc();
+    if (!packet)
+        return finish(2);
+
+    while (m_url == url) {
+        lock.unlock();
+        error = av_read_frame(format_context, packet);
+        lock.lock();
+        if (m_url != url)
+            break;
+        if (error < 0)
+            break;
+        if (packet->stream_index == video_stream) {
+            const int decode_error = decoder.decode(*packet);
+            if (decode_error == 0) {
+                if (!have_size) {
+                    have_size = apply_video_size(decoder.decoded_frame_size());
+                    if (!have_size) {
+                        av_packet_unref(packet);
+                        // MJPEG yields a sized frame on the first full packet; if
+                        // several seconds of frames never do, treat it as a bad
+                        // stream instead of sitting in "Loading..." forever.
+                        if (++size_probe_frames > 120)
+                            break;
+                        continue;
+                    }
+                }
+                auto frame_size = m_frame_size;
+                lock.unlock();
+#ifdef _WIN32
+                wxBitmap frame;
+                decoder.toWxBitmap(frame, frame_size);
+#else
+                wxImage frame;
+                decoder.toWxImage(frame, frame_size);
+#endif
+                lock.lock();
+                if (m_url != url)
+                    break;
+                if (frame.IsOk())
+                    m_frame = frame;
+                if (!m_refresh_pending.exchange(true)) {
+                    CallAfter([this] {
+                        m_refresh_pending.store(false);
+                        Refresh();
+                    });
+                }
+            }
+        }
+        av_packet_unref(packet);
+    }
+
+    av_packet_free(&packet);
+    return finish(m_url == url ? 2 : 1);
+}
+
 void wxMediaCtrl3::PlayThread()
 {
     using namespace std::chrono_literals;
@@ -197,42 +471,22 @@ void wxMediaCtrl3::PlayThread()
             continue;
         if (!url->HasScheme())
             break;
-        lk.unlock();
-        Bambu_Tunnel tunnel = nullptr;
-        int error = Bambu_Create(&tunnel, m_url->BuildURI().ToUTF8());
-        if (error == 0) {
-            Bambu_SetLogger(tunnel, &wxMediaCtrl3::bambu_log, this);
-            error = Bambu_Open(tunnel);
-            if (error == 0)
-                error = Bambu_would_block;
-        }
-        lk.lock();
-        while (error == int(Bambu_would_block)) {
-            m_cond.wait_for(lk, 100ms);
-            if (m_url != url) {
-                error = 1;
-                break;
+        const wxString scheme = url->GetScheme();
+        const bool generic_ffmpeg = scheme.CmpNoCase("http") == 0 || scheme.CmpNoCase("https") == 0 ||
+                                    scheme.CmpNoCase("rtsp") == 0 || scheme.CmpNoCase("rtsps") == 0;
+        int error = 0;
+        if (generic_ffmpeg) {
+            error = PlayFfmpeg(url, lk);
+        } else {
+            lk.unlock();
+            Bambu_Tunnel tunnel = nullptr;
+            error = Bambu_Create(&tunnel, m_url->BuildURI().ToUTF8());
+            if (error == 0) {
+                Bambu_SetLogger(tunnel, &wxMediaCtrl3::bambu_log, this);
+                error = Bambu_Open(tunnel);
+                if (error == 0)
+                    error = Bambu_would_block;
             }
-            lk.unlock();
-            error = Bambu_StartStream(tunnel, true);
-            lk.lock();
-        }
-        Bambu_StreamInfo info;
-        if (error == 0)
-            error = Bambu_GetStreamInfo(tunnel, 0, &info);
-        AVVideoDecoder decoder;
-        int minFrameDuration = 0;
-        if (error == 0) {
-            decoder.open(info);
-            m_video_size = { info.format.video.width, info.format.video.height };
-            adjust_frame_size(m_frame_size, m_video_size, GetSize());
-            minFrameDuration = 800 / info.format.video.frame_rate; // 80%
-            NotifyStopped();
-        }
-        Bambu_Sample sample;
-        while (error == 0) {
-            lk.unlock();
-            error = Bambu_ReadSample(tunnel, &sample);
             lk.lock();
             while (error == int(Bambu_would_block)) {
                 m_cond.wait_for(lk, 100ms);
@@ -240,59 +494,87 @@ void wxMediaCtrl3::PlayThread()
                     error = 1;
                     break;
                 }
+                lk.unlock();
+                error = Bambu_StartStream(tunnel, true);
+                lk.lock();
+            }
+            Bambu_StreamInfo info;
+            if (error == 0)
+                error = Bambu_GetStreamInfo(tunnel, 0, &info);
+            AVVideoDecoder decoder;
+            int minFrameDuration = 0;
+            if (error == 0) {
+                decoder.open(info);
+                m_video_size = { info.format.video.width, info.format.video.height };
+                adjust_frame_size(m_frame_size, m_video_size, GetSize());
+                minFrameDuration = 800 / info.format.video.frame_rate; // 80%
+                NotifyStopped();
+            }
+            Bambu_Sample sample;
+            while (error == 0) {
                 lk.unlock();
                 error = Bambu_ReadSample(tunnel, &sample);
                 lk.lock();
-            }
-            if (error == 0) {
-                auto frame_size = m_frame_size;
-                lk.unlock();
-                decoder.decode(sample);
-#ifdef _WIN32
-                wxBitmap bm;
-                decoder.toWxBitmap(bm, frame_size);
-#else
-                wxImage bm;
-                decoder.toWxImage(bm, frame_size);
-#endif
-                lk.lock();
-                if (m_url != url) {
-                    error = 1;
-                    break;
-                }
-                if (bm.IsOk()) {
-                    auto now = std::chrono::system_clock::now();
-                    if (m_last_PTS && (sample.decode_time - m_last_PTS) < 30000000ULL) { // 3s
-                        auto next_PTS_expected = m_last_PTS_expected + std::chrono::milliseconds((sample.decode_time - m_last_PTS) / 10000ULL);
-                        // The frame is late, catch up a little
-                        auto next_PTS_practical = m_last_PTS_practical + std::chrono::milliseconds(minFrameDuration);
-                        auto next_PTS = std::max(next_PTS_expected, next_PTS_practical);
-                        if(now < next_PTS)
-                            std::this_thread::sleep_until(next_PTS);
-                        else
-                            next_PTS = now;
-                        //auto text = wxString::Format(L"wxMediaCtrl3 pts diff %ld\n", std::chrono::duration_cast<std::chrono::milliseconds>(next_PTS - next_PTS_expected).count());
-                        //OutputDebugString(text);
-                        m_last_PTS = sample.decode_time;
-                        m_last_PTS_expected = next_PTS_expected;
-                        m_last_PTS_practical = next_PTS;
-                    } else {
-                        // Resync
-                        m_last_PTS           = sample.decode_time;
-                        m_last_PTS_expected  = now;
-                        m_last_PTS_practical = now;
+                while (error == int(Bambu_would_block)) {
+                    m_cond.wait_for(lk, 100ms);
+                    if (m_url != url) {
+                        error = 1;
+                        break;
                     }
-                    m_frame = bm;
+                    lk.unlock();
+                    error = Bambu_ReadSample(tunnel, &sample);
+                    lk.lock();
+                }
+                if (error == 0) {
+                    auto frame_size = m_frame_size;
+                    lk.unlock();
+                    decoder.decode(sample);
+#ifdef _WIN32
+                    wxBitmap bm;
+                    decoder.toWxBitmap(bm, frame_size);
+#else
+                    wxImage bm;
+                    decoder.toWxImage(bm, frame_size);
+#endif
+                    lk.lock();
+                    if (m_url != url) {
+                        error = 1;
+                        break;
+                    }
+                    if (bm.IsOk()) {
+                        auto now = std::chrono::system_clock::now();
+                        if (m_last_PTS && (sample.decode_time - m_last_PTS) < 30000000ULL) { // 3s
+                            auto next_PTS_expected = m_last_PTS_expected + std::chrono::milliseconds((sample.decode_time - m_last_PTS) / 10000ULL);
+                            // The frame is late, catch up a little
+                            auto next_PTS_practical = m_last_PTS_practical + std::chrono::milliseconds(minFrameDuration);
+                            auto next_PTS = std::max(next_PTS_expected, next_PTS_practical);
+                            if(now < next_PTS)
+                                std::this_thread::sleep_until(next_PTS);
+                            else
+                                next_PTS = now;
+                            //auto text = wxString::Format(L"wxMediaCtrl3 pts diff %ld\n", std::chrono::duration_cast<std::chrono::milliseconds>(next_PTS - next_PTS_expected).count());
+                            //OutputDebugString(text);
+                            m_last_PTS = sample.decode_time;
+                            m_last_PTS_expected = next_PTS_expected;
+                            m_last_PTS_practical = next_PTS;
+                        } else {
+                            // Resync
+                            m_last_PTS           = sample.decode_time;
+                            m_last_PTS_expected  = now;
+                            m_last_PTS_practical = now;
+                        }
+                        m_frame = bm;
+                    }
+                    CallAfter([this] { Refresh(); });
                 }
-                CallAfter([this] { Refresh(); });
             }
-        }
-        if (tunnel) {
-            lk.unlock();
-            Bambu_Close(tunnel);
-            Bambu_Destroy(tunnel);
-            tunnel = nullptr;
-            lk.lock();
+            if (tunnel) {
+                lk.unlock();
+                Bambu_Close(tunnel);
+                Bambu_Destroy(tunnel);
+                tunnel = nullptr;
+                lk.lock();
+            }
         }
         if (m_url == url)
             m_error = error;

src/slic3r/GUI/wxMediaCtrl3.h

@@ -19,11 +19,10 @@ wxDECLARE_EVENT(EVT_MEDIA_CTRL_STAT, wxCommandEvent);
 void wxMediaCtrl_OnSize(wxWindow * ctrl, wxSize const & videoSize, int width, int height);
 
 #define BAMBU_DYNAMIC
+#include <atomic>
 #include <condition_variable>
 #include <thread>
-#ifndef _WIN32
 #include <wx/image.h>
-#endif
 #include "Printer/BambuTunnel.h"
 
 class AVVideoDecoder;
@@ -41,6 +40,16 @@ public:
 
     void Stop();
 
+    // Render frames supplied by a controller which owns its own transport.
+    // The frame is copied while m_mutex is held; callers may release it after
+    // this method returns.
+    void SetExternalFrame(const wxImage& frame, wxSize videoSize);
+#ifdef _WIN32
+    void SetExternalFrame(const wxBitmap& frame, wxSize videoSize);
+#endif
+    void BeginExternalStream();
+    void EndExternalStream();
+
     void SetIdleImage(wxString const & image);
 
     wxMediaState GetState();
@@ -59,8 +68,10 @@ protected:
     void DoSetSize(int x, int y, int width, int height, int sizeFlags) override;
 
     static void bambu_log(void *ctx, int level, tchar const *msg);
+    static int ffmpeg_interrupt_callback(void *opaque);
 
     void PlayThread();
+    int PlayFfmpeg(std::shared_ptr<wxURI> const &url, std::unique_lock<std::mutex> &lock);
 
     void NotifyStopped();
 
@@ -77,12 +88,15 @@ private:
 #endif
 
     std::shared_ptr<wxURI> m_url;
+    std::shared_ptr<wxURI> m_active_url;
+    bool m_external = false;
     std::uint64_t m_last_PTS{0};
     std::chrono::system_clock::time_point m_last_PTS_expected;
     std::chrono::system_clock::time_point m_last_PTS_practical;
     std::mutex m_mutex;
     std::condition_variable m_cond;
     std::thread m_thread;
+    std::atomic_bool m_refresh_pending{false};
 };
 
 #endif /* wxMediaCtrl3_h */

src/slic3r/Utils/AmsPayload.cpp

@@ -0,0 +1,493 @@
+#include "AmsPayload.hpp"
+
+#include "libslic3r/Preset.hpp"
+#include "libslic3r/PresetBundle.hpp"
+#include "slic3r/GUI/GUI_App.hpp"
+#include "slic3r/GUI/DeviceManager.hpp"
+#include "slic3r/GUI/DeviceCore/DevFilaSystem.h"
+#include "slic3r/GUI/DeviceCore/DevManager.h"
+#include "slic3r/GUI/DeviceCore/DevStorage.h"
+#include "slic3r/GUI/DeviceCore/DevFirmware.h"
+
+#include <boost/algorithm/string.hpp>
+#include <boost/log/trivial.hpp>
+#include <wx/thread.h>
+
+#include <algorithm>
+#include <cctype>
+#include <chrono>
+#include <cstdint>
+#include <map>
+#include <mutex>
+#include <sstream>
+
+namespace Slic3r {
+
+std::string map_filament_type_to_generic_id(const std::string& filament_type)
+{
+    std::string upper = filament_type;
+    boost::trim(upper);
+    std::transform(upper.begin(), upper.end(), upper.begin(),
+                   [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
+
+    // Normalize reported material names to an OrcaFilamentLibrary generic family. The
+    // family's filament_id is resolved from the loaded system presets below rather than
+    // hardcoded, so profile id re-mints never require touching this table.
+    // scripts/test_moonraker_lane_data.py parses this initializer; keep the {"A", "B"} format.
+    static const std::map<std::string, std::string> type_to_ofl_family = {
+        // PLA variants
+        {"PLA", "PLA"},
+        {"PLA-CF", "PLA-CF"},
+        {"PLA SILK", "PLA Silk"},
+        {"PLA-SILK", "PLA Silk"},
+        {"PLA HIGH SPEED", "PLA High Speed"},
+        {"PLA-HS", "PLA High Speed"},
+        {"PLA HS", "PLA High Speed"},
+
+        // ABS/ASA variants
+        {"ABS", "ABS"},
+        {"ASA", "ASA"},
+
+        // PETG/PET variants
+        {"PETG", "PETG"},
+        {"PET", "PETG"},
+        {"PCTG", "PCTG"},
+
+        // PA/Nylon variants
+        {"PA", "PA"},
+        {"NYLON", "PA"},
+        {"PA-CF", "PA-CF"},
+        {"PPA", "PPA-CF"},
+        {"PPA-CF", "PPA-CF"},
+        {"PPA-GF", "PPA-GF"},
+
+        // PC variants
+        {"PC", "PC"},
+
+        // PP/PE variants
+        {"PE", "PE"},
+        {"PP", "PP"},
+
+        // Support materials
+        {"PVA", "PVA"},
+        {"HIPS", "HIPS"},
+        {"BVOH", "BVOH"},
+
+        // TPU variants
+        {"TPU", "TPU"},
+
+        // Other materials
+        {"EVA", "EVA"},
+        {"PHA", "PHA"},
+        {"COPE", "CoPE"},
+        {"SBS", "SBS"},
+    };
+
+    auto it = type_to_ofl_family.find(upper);
+    if (it == type_to_ofl_family.end())
+        return UNKNOWN_FILAMENT_ID;
+
+    if (auto* bundle = GUI::wxGetApp().preset_bundle) {
+        const Preset* preset = bundle->filaments.find_preset("Generic " + it->second + " @System");
+        if (preset != nullptr && preset->is_system && !preset->filament_id.empty())
+            return preset->filament_id;
+    }
+
+    // Unknown material, or no loaded preset data to resolve against
+    return UNKNOWN_FILAMENT_ID;
+}
+
+std::string normalize_ams_color(const std::string& color)
+{
+    std::string value = color;
+    boost::trim(value);
+
+    // Remove 0x or 0X prefix if present
+    if (value.size() >= 2 && (value.rfind("0x", 0) == 0 || value.rfind("0X", 0) == 0)) {
+        value = value.substr(2);
+    }
+    // Remove # prefix if present
+    if (!value.empty() && value[0] == '#') {
+        value = value.substr(1);
+    }
+
+    // Extract only hex digits
+    std::string normalized;
+    for (char c : value) {
+        if (std::isxdigit(static_cast<unsigned char>(c))) {
+            normalized.push_back(static_cast<char>(std::toupper(static_cast<unsigned char>(c))));
+        }
+    }
+
+    // If 6 hex digits, add FF alpha
+    if (normalized.size() == 6) {
+        normalized += "FF";
+    }
+
+    // Validate length - return default if invalid
+    if (normalized.size() != 8) {
+        return "00000000";
+    }
+
+    return normalized;
+}
+
+bool parse_moonraker_lane_data(const nlohmann::json& body,
+                               std::vector<AmsTrayData>& trays,
+                               int& max_lane_index)
+{
+    // Expected structure: { "result": { "namespace": "lane_data", "value": { "lane1": {...}, ... } } }
+    if (!body.is_object() || !body.contains("result") || !body["result"].is_object() ||
+        !body["result"].contains("value") || !body["result"]["value"].is_object()) {
+        BOOST_LOG_TRIVIAL(warning) << "AmsPayload: unexpected lane_data response structure";
+        return false;
+    }
+
+    const auto& value = body["result"]["value"];
+    trays.clear();
+    max_lane_index = 0;
+
+    for (const auto& lane_item : value.items()) {
+        const auto& lane_obj = lane_item.value();
+        if (!lane_obj.is_object()) {
+            continue;
+        }
+
+        // Extract lane index from the "lane" field (tool number, 0-based)
+        int lane_index = -1;
+        const auto lane_it = lane_obj.find("lane");
+        if (lane_it != lane_obj.end() && lane_it->is_string()) {
+            try {
+                lane_index = std::stoi(lane_it->get<std::string>());
+            } catch (...) {
+                lane_index = -1;
+            }
+        }
+
+        if (lane_index < 0) {
+            continue;
+        }
+
+        AmsTrayData tray;
+        tray.slot_index = lane_index;
+        if (const auto it = lane_obj.find("color"); it != lane_obj.end() && it->is_string())
+            tray.tray_color = it->get<std::string>();
+        if (const auto it = lane_obj.find("material"); it != lane_obj.end() && it->is_string())
+            tray.tray_type = it->get<std::string>();
+        if (const auto it = lane_obj.find("bed_temp"); it != lane_obj.end() && it->is_number())
+            tray.bed_temp = it->get<int>();
+        if (const auto it = lane_obj.find("nozzle_temp"); it != lane_obj.end() && it->is_number())
+            tray.nozzle_temp = it->get<int>();
+
+        // Presence is independent of declared material: a physically loaded lane
+        // with no user-declared material must not read as empty. Prefer an
+        // explicit signal, fall back to the legacy "has a material type" rule.
+        const auto has_it = lane_obj.find("has_filament");
+        const auto loaded_it = lane_obj.find("loaded");
+        if (has_it != lane_obj.end() && has_it->is_boolean())
+            tray.has_filament = has_it->get<bool>();
+        else if (loaded_it != lane_obj.end() && loaded_it->is_boolean())
+            tray.has_filament = loaded_it->get<bool>();
+        else
+            tray.has_filament = !tray.tray_type.empty();
+
+        max_lane_index = std::max(max_lane_index, lane_index);
+        trays.push_back(tray);
+    }
+
+    if (trays.empty()) {
+        BOOST_LOG_TRIVIAL(info) << "AmsPayload: no lanes found";
+        return false;
+    }
+
+    return true;
+}
+
+void resolve_tray_info_idx(std::vector<AmsTrayData>& trays)
+{
+    auto* bundle = GUI::wxGetApp().preset_bundle;
+    for (auto& tray : trays) {
+        // Absent lanes render as placeholders; resolving an empty type is busy
+        // work at best and could bind a bogus id.
+        if (!tray.has_filament)
+            continue;
+        // A vendor-aware resolver may already have matched this lane; only fill
+        // what is still empty so the generic fallback cannot overwrite it.
+        if (!tray.tray_info_idx.empty())
+            continue;
+        tray.tray_info_idx = bundle
+            ? bundle->filaments.filament_id_by_type(tray.tray_type)
+            : map_filament_type_to_generic_id(tray.tray_type);
+    }
+}
+
+nlohmann::json build_bbl_ams_json(const std::vector<AmsTrayData>& trays,
+                                  int ams_count,
+                                  int max_lane_index)
+{
+    nlohmann::json ams_array = nlohmann::json::array();
+
+    // ams_exist_bits marks the units; tray_exist_bits marks the occupied
+    // slots. uint64_t: unsigned long is 32-bit on MSVC, so 1UL << 32+ is UB.
+    // BBL's fields are 64-bit; a lane past 63 cannot be represented at all.
+    uint64_t ams_exist_bits = 0;
+    uint64_t tray_exist_bits = 0;
+
+    auto set_exist_bit = [](uint64_t& bits, int index) {
+        if (index < 0)
+            return;
+        if (index >= 64) {
+            BOOST_LOG_TRIVIAL(warning) << "AmsPayload: lane index " << index << " exceeds the 64-bit exist-bits field; bit dropped";
+            return;
+        }
+        bits |= (uint64_t{1} << index);
+    };
+
+    for (int ams_id = 0; ams_id < ams_count; ++ams_id) {
+        set_exist_bit(ams_exist_bits, ams_id);
+
+        nlohmann::json ams_unit = nlohmann::json::object();
+        ams_unit["id"] = std::to_string(ams_id);
+        ams_unit["info"] = "0002";  // treat as AMS_LITE
+
+        nlohmann::json tray_array = nlohmann::json::array();
+        int max_slot_in_this_ams = std::min(3, max_lane_index - ams_id * 4);
+        for (int slot_id = 0; slot_id <= max_slot_in_this_ams; ++slot_id) {
+            int slot_index = ams_id * 4 + slot_id;
+
+            // Find tray with matching slot_index
+            const AmsTrayData* tray = nullptr;
+            for (const auto& t : trays) {
+                if (t.slot_index == slot_index) {
+                    tray = &t;
+                    break;
+                }
+            }
+
+            nlohmann::json tray_json = nlohmann::json::object();
+            tray_json["id"] = std::to_string(slot_id);
+            tray_json["tag_uid"] = "0000000000000000";
+
+            if (tray && tray->has_filament) {
+                set_exist_bit(tray_exist_bits, slot_index);
+
+                // Present lanes never carry tray_slot_placeholder: a loaded but
+                // undeclared lane stays occupied with an empty type, which is
+                // what distinguishes it from an absent slot.
+                tray_json["tray_info_idx"] = tray->tray_info_idx;
+                tray_json["tray_type"] = tray->tray_type;
+                tray_json["tray_color"] = normalize_ams_color(tray->tray_color);
+
+                // Add temperature data if provided
+                if (tray->bed_temp > 0) {
+                    tray_json["bed_temp"] = std::to_string(tray->bed_temp);
+                }
+                if (tray->nozzle_temp > 0) {
+                    tray_json["nozzle_temp_max"] = std::to_string(tray->nozzle_temp);
+                }
+            } else {
+                tray_json["tray_info_idx"] = "";
+                tray_json["tray_type"] = "";
+                tray_json["tray_color"] = "00000000";
+                tray_json["tray_slot_placeholder"] = "1";
+            }
+
+            tray_array.push_back(tray_json);
+        }
+        ams_unit["tray"] = tray_array;
+        ams_array.push_back(ams_unit);
+    }
+
+    // Format as hex strings (matching BBL protocol)
+    std::ostringstream ams_exist_ss;
+    ams_exist_ss << std::hex << std::uppercase << ams_exist_bits;
+    std::ostringstream tray_exist_ss;
+    tray_exist_ss << std::hex << std::uppercase << tray_exist_bits;
+
+    nlohmann::json ams_json = nlohmann::json::object();
+    ams_json["ams"] = ams_array;
+    ams_json["ams_exist_bits"] = ams_exist_ss.str();
+    ams_json["tray_exist_bits"] = tray_exist_ss.str();
+    return ams_json;
+}
+
+// --- Removal/absence state and op capability ---------------------------------
+
+// Last ams_count rendered per device: clear_ams_payload_for_device walks the
+// same unit set to mark them all absent.
+static std::mutex              g_ams_state_mutex;
+static std::map<std::string, int>             g_ams_last_count;
+static std::map<std::string, std::vector<std::string>> g_ams_ops;
+static std::map<std::string, bool>            g_ams_capability;
+
+static void remember_ams_count(const std::string& dev_id, int ams_count)
+{
+    if (dev_id.empty() || ams_count <= 0)
+        return;
+    std::lock_guard<std::mutex> lock(g_ams_state_mutex);
+    g_ams_last_count[dev_id] = std::max(g_ams_last_count[dev_id], ams_count);
+}
+
+void register_ams_ops(const std::string& dev_id, const std::vector<std::string>& ops)
+{
+    if (dev_id.empty())
+        return;
+    std::lock_guard<std::mutex> lock(g_ams_state_mutex);
+    g_ams_ops[dev_id] = ops;
+}
+
+bool ams_op_supported(const std::string& dev_id, const std::string& op)
+{
+    std::lock_guard<std::mutex> lock(g_ams_state_mutex);
+    auto it = g_ams_ops.find(dev_id);
+    if (it == g_ams_ops.end())
+        return true; // no OrcaSonar capabilities seen: never gate
+    return std::find(it->second.begin(), it->second.end(), op) != it->second.end();
+}
+
+void register_ams_capability(const std::string& dev_id, bool has_ams)
+{
+    if (dev_id.empty())
+        return;
+    std::lock_guard<std::mutex> lock(g_ams_state_mutex);
+    g_ams_capability[dev_id] = has_ams;
+}
+
+bool has_ams_capability(const std::string& dev_id)
+{
+    std::lock_guard<std::mutex> lock(g_ams_state_mutex);
+    auto it = g_ams_capability.find(dev_id);
+    return it != g_ams_capability.end() && it->second;
+}
+
+void build_ams_payload_for_device(const std::string& dev_id,
+                                  const std::optional<std::string>& printer_type,
+                                  int ams_count,
+                                  int max_lane_index,
+                                  const std::vector<AmsTrayData>& trays,
+                                  const QueueOnMainFn& queue_fn,
+                                  const TrayInfoResolver& vendor_resolver)
+{
+    remember_ams_count(dev_id, ams_count);
+    // A caller on the GUI thread must mutate DeviceManager inline: invoking
+    // queue_fn (CallAfter) would defer the work until after the caller has
+    // already read DevFilaSystem. Background callers route through queue_fn.
+    const bool on_main = wxIsMainThread();
+    auto apply = [dev_id, printer_type, ams_count, max_lane_index, trays, vendor_resolver]() {
+    // Look up MachineObject via DeviceManager
+    auto* dev_manager = GUI::wxGetApp().getDeviceManager();
+    if (!dev_manager) {
+        return;
+    }
+    MachineObject* obj = dev_manager->get_my_machine(dev_id);
+    if (!obj) {
+        return;
+    }
+
+    // Resolve preset ids here: reads the GUI preset bundle, which is only safe
+    // on the main thread. trays is a copy, so mutating it is fine. The optional
+    // vendor resolver runs first; the generic resolver fills the rest.
+    std::vector<AmsTrayData> resolved = trays;
+    if (vendor_resolver)
+        vendor_resolver(resolved);
+    resolve_tray_info_idx(resolved);
+
+    // Wrap in the expected structure for ParseV1_0
+    nlohmann::json print_json = nlohmann::json::object();
+    print_json["ams"] = build_bbl_ams_json(resolved, ams_count, max_lane_index);
+
+    // Call the parser to populate DevFilaSystem
+    DevFilaSystemParser::ParseV1_0(print_json, obj, obj->GetFilaSystem().get(), false);
+    BOOST_LOG_TRIVIAL(info) << "AmsPayload: parsed " << resolved.size() << " trays";
+
+    // Set printer_type so update_sync_status() can match it against the preset's
+    // printer type. nullopt = leave it (the caller's push_status already carries
+    // it); a value = assign, including empty, preserving the old behavior.
+    if (printer_type.has_value()) {
+        obj->printer_type = *printer_type;
+    }
+
+    // Set push counters so is_info_ready() returns true for pull-mode agents.
+    if (obj->m_push_count == 0) {
+        obj->m_push_count = 1;
+    }
+    if (obj->m_full_msg_count == 0) {
+        obj->m_full_msg_count = 1;
+    }
+    obj->last_push_time = std::chrono::system_clock::now();
+
+    // Set storage state - Moonraker printers use virtual_sdcard, storage is always available.
+    // This is required for SelectMachineDialog to allow printing (otherwise it blocks with "No SD card").
+    obj->GetStorage()->set_sdcard_state(DevStorage::HAS_SDCARD_NORMAL);
+
+    // Populate module_vers so is_info_ready() passes the version check.
+    if (obj->module_vers.empty()) {
+        DevFirmwareVersionInfo ota_info;
+        ota_info.name = "ota";
+        ota_info.sw_ver = "1.0.0";  // Placeholder version
+        obj->module_vers.emplace("ota", ota_info);
+    }
+    };
+
+    if (queue_fn && !on_main) {
+        queue_fn(apply);
+    } else {
+        apply();
+    }
+}
+
+void clear_ams_payload_for_device(const std::string& dev_id, const QueueOnMainFn& queue_fn)
+{
+    int count = 0;
+    {
+        std::lock_guard<std::mutex> lock(g_ams_state_mutex);
+        auto it = g_ams_last_count.find(dev_id);
+        if (it != g_ams_last_count.end())
+            count = it->second;
+        g_ams_last_count[dev_id] = 0;
+    }
+    if (count == 0)
+        return; // nothing was ever rendered: nothing to clear
+
+    const bool on_main = wxIsMainThread();
+    auto apply = [dev_id, count]() {
+        auto* dev_manager = GUI::wxGetApp().getDeviceManager();
+        if (!dev_manager)
+            return;
+        MachineObject* obj = dev_manager->get_my_machine(dev_id);
+        if (!obj)
+            return;
+
+        // All units present-but-empty: exist bits 0 marks them absent while
+        // placeholder trays flush stale type/color data out of DevFilaSystem.
+        nlohmann::json units = nlohmann::json::array();
+        for (int ams_id = 0; ams_id < count; ++ams_id) {
+            nlohmann::json trays = nlohmann::json::array();
+            for (int slot_id = 0; slot_id < 4; ++slot_id) {
+                trays.push_back(nlohmann::json{
+                    {"id", std::to_string(slot_id)},
+                    {"tag_uid", "0000000000000000"},
+                    {"tray_info_idx", ""},
+                    {"tray_type", ""},
+                    {"tray_color", "00000000"},
+                    {"tray_slot_placeholder", "1"},
+                });
+            }
+            units.push_back(nlohmann::json{{"id", std::to_string(ams_id)}, {"info", "0002"}, {"tray", trays}});
+        }
+        nlohmann::json ams_json;
+        ams_json["ams"]                = units;
+        ams_json["ams_exist_bits"]     = "0";
+        ams_json["tray_exist_bits"]    = "0";
+        nlohmann::json print_json;
+        print_json["ams"] = ams_json;
+        DevFilaSystemParser::ParseV1_0(print_json, obj, obj->GetFilaSystem().get(), false);
+        BOOST_LOG_TRIVIAL(info) << "AmsPayload: cleared " << count << " AMS units for " << dev_id;
+    };
+    if (queue_fn && !on_main)
+        queue_fn(apply);
+    else
+        apply();
+}
+
+} // namespace Slic3r

src/slic3r/Utils/AmsPayload.hpp

@@ -0,0 +1,93 @@
+#ifndef __AMS_PAYLOAD_HPP__
+#define __AMS_PAYLOAD_HPP__
+
+#include "bambu_networking.hpp"
+
+#include <functional>
+#include <nlohmann/json.hpp>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace Slic3r {
+
+// One lane of a multi-material system in the neutral shape every printer agent
+// shares before it is rendered into the BBL AMS payload.
+struct AmsTrayData {
+    int         slot_index = 0;      // 0-based global slot index
+    bool        has_filament = false;
+    std::string tray_type;           // Material type (e.g. "PLA", "ASA")
+    std::string tray_color;          // Raw color (#RRGGBB, 0xRRGGBB, or RRGGBBAA)
+    std::string tray_info_idx;       // OrcaFilamentLibrary preset id (optional)
+    int         bed_temp = 0;        // Optional
+    int         nozzle_temp = 0;     // Optional
+};
+
+// Normalize a driver color string to the BBL RRGGBBAA form; "00000000" when invalid.
+std::string normalize_ams_color(const std::string& color);
+
+// Map a reported material type to an OrcaFilamentLibrary generic family id.
+std::string map_filament_type_to_generic_id(const std::string& filament_type);
+
+// Parse a Moonraker `/server/database/item?namespace=lane_data` response body:
+// result.value is keyed by lane, each entry carrying "lane", optional
+// "material"/"color"/"bed_temp"/"nozzle_temp" and an optional presence signal
+// ("has_filament" or "loaded"). Presence is preferred over material: a loaded
+// lane with no declared material must not read as empty. Returns false when
+// malformed or empty. Pure: tray_info_idx is left for resolve_tray_info_idx().
+bool parse_moonraker_lane_data(const nlohmann::json& body,
+                               std::vector<AmsTrayData>& trays,
+                               int& max_lane_index);
+
+// Fill each tray's tray_info_idx from the loaded preset bundle (falling back to
+// the generic family map). Reads GUI preset state, so it MUST run on the main
+// thread. Ids already set by a vendor-aware resolver are left untouched.
+void resolve_tray_info_idx(std::vector<AmsTrayData>& trays);
+
+// Optional vendor-aware resolver, run on the main thread before the generic
+// resolver. Agents with brand/color matching (Snapmaker, Creality) supply one
+// so their results survive the shared path; the generic resolver only fills
+// ids this leaves empty.
+using TrayInfoResolver = std::function<void(std::vector<AmsTrayData>&)>;
+
+// Assemble the BBL-format AMS JSON (ams[] units + ams_exist_bits/tray_exist_bits)
+// that DevFilaSystemParser::ParseV1_0 consumes. Pure and GUI-free: the
+// MachineObject mutation stays in build_ams_payload_for_device.
+nlohmann::json build_bbl_ams_json(const std::vector<AmsTrayData>& trays,
+                                  int ams_count,
+                                  int max_lane_index);
+
+// Render trays into the BBL AMS payload and populate the device's DevFilaSystem.
+// The resolver and the MachineObject mutation both run on the main thread via
+// queue_fn when set. printer_type: nullopt leaves obj->printer_type untouched
+// (OrcaSonar, whose push_status already carries it); a value assigns it
+// verbatim (Moonraker).
+void build_ams_payload_for_device(const std::string& dev_id,
+                                  const std::optional<std::string>& printer_type,
+                                  int ams_count,
+                                  int max_lane_index,
+                                  const std::vector<AmsTrayData>& trays,
+                                  const QueueOnMainFn& queue_fn,
+                                  const TrayInfoResolver& vendor_resolver = {});
+
+// Clear the device's AMS view: render every previously-seen unit as absent
+// with placeholder trays so a removed/absent material system never leaves
+// stale filament data behind (lane_data read as authoritative empty).
+void clear_ams_payload_for_device(const std::string& dev_id, const QueueOnMainFn& queue_fn);
+
+// Process-wide canonical AMS write capability (OrcaSonar REQ-STS-008), parsed
+// from the info.get_capabilities reply. Devices with no record (Bambu, cloud
+// profiles) report every op supported: gating only ever applies to OrcaSonar
+// printers that answered.
+void   register_ams_ops(const std::string& dev_id, const std::vector<std::string>& ops);
+bool   ams_op_supported(const std::string& dev_id, const std::string& op);
+
+// Whether the device has a material system, from the get_capabilities reply's
+// protocol.features.fms (falling back to a non-empty ams_ops). No record reads
+// false: an unconfirmed printer must not advertise filament sync.
+void   register_ams_capability(const std::string& dev_id, bool has_ams);
+bool   has_ams_capability(const std::string& dev_id);
+
+} // namespace Slic3r
+
+#endif

src/slic3r/Utils/BBLPrinterAgent.cpp

@@ -1,8 +1,11 @@
 #include "BBLPrinterAgent.hpp"
 #include "BBLNetworkPlugin.hpp"
+#include "IPrinterAgent.hpp"
 #include "NetworkAgentFactory.hpp"
 #include "libslic3r/Utils.hpp"
+#include "NetworkAgent.hpp"
 
+#include <boost/format.hpp>
 #include <boost/log/trivial.hpp>
 #include <boost/nowide/fstream.hpp>
 #include <nlohmann/json.hpp>
@@ -10,6 +13,10 @@ 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 {
 
@@ -133,7 +140,7 @@ BBLPrinterAgent::~BBLPrinterAgent() = default;
 
 void BBLPrinterAgent::set_cloud_agent(std::shared_ptr<ICloudServiceAgent> cloud)
 {
-    m_cloud_agent = cloud;
+    (void) cloud;
     // BBL DLL manages tokens internally, so this is just for interface compliance
 }
 
@@ -141,6 +148,163 @@ void BBLPrinterAgent::set_cloud_agent(std::shared_ptr<ICloudServiceAgent> cloud)
 // Communication
 // ============================================================================
 
+std::string BBLPrinterAgent::ams_refresh_rfid_gcode(const std::string& tray_id)
+{
+    return (boost::format("M620 R%1% \n") % tray_id).str();
+}
+
+std::string BBLPrinterAgent::ams_calibrate_gcode(int ams_id)
+{
+    return (boost::format("M620 C%1% \n") % ams_id).str();
+}
+
+std::string BBLPrinterAgent::ams_select_tray_gcode(const std::string& tray_id)
+{
+    return (boost::format("M620 P%1% \n") % tray_id).str();
+}
+
+int BBLPrinterAgent::command_ams_refresh_rfid(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode)
+{
+    const std::string gcode = ams_refresh_rfid_gcode(tray_id);
+    BOOST_LOG_TRIVIAL(trace) << "ams_debug: gcode_cmd" << gcode;
+    nlohmann::json j;
+    j["print"]["command"] = "gcode_line";
+    j["print"]["param"] = gcode;
+    j["print"]["sequence_id"] = std::to_string(sequence_id);
+    return publish(dev_id, j, lan_mode);
+}
+
+int BBLPrinterAgent::command_ams_calibrate(std::string dev_id, int ams_id, int sequence_id, bool lan_mode)
+{
+    const std::string gcode = ams_calibrate_gcode(ams_id);
+    BOOST_LOG_TRIVIAL(trace) << "ams_debug: gcode_cmd" << gcode;
+    nlohmann::json j;
+    j["print"]["command"] = "gcode_line";
+    j["print"]["param"] = gcode;
+    j["print"]["sequence_id"] = std::to_string(sequence_id);
+    return publish(dev_id, j, lan_mode);
+}
+
+int BBLPrinterAgent::command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode)
+{
+    const std::string gcode = ams_select_tray_gcode(tray_id);
+    BOOST_LOG_TRIVIAL(trace) << "ams_debug: gcode_cmd" << gcode;
+    nlohmann::json j;
+    j["print"]["command"] = "gcode_line";
+    j["print"]["param"] = gcode;
+    j["print"]["sequence_id"] = std::to_string(sequence_id);
+    return publish(dev_id, j, lan_mode);
+}
+
+int BBLPrinterAgent::command_xyz_abs(std::string dev_id, int sequence_id, bool lan_mode)
+{
+    nlohmann::json j;
+    j["print"]["command"] = "gcode_line";
+    j["print"]["param"] = "G90 \n";
+    j["print"]["sequence_id"] = std::to_string(sequence_id);
+    return publish(dev_id, j, lan_mode);
+}
+
+int BBLPrinterAgent::command_auto_leveling(std::string dev_id, int sequence_id, bool lan_mode)
+{
+    nlohmann::json j;
+    j["print"]["command"] = "gcode_line";
+    j["print"]["param"] = "G29 \n";
+    j["print"]["sequence_id"] = std::to_string(sequence_id);
+    return publish(dev_id, j, lan_mode);
+}
+
+int BBLPrinterAgent::command_go_home(std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode)
+{
+    nlohmann::json j;
+    j["print"]["sequence_id"] = std::to_string(sequence_id);
+    if (supports_mqtt_homing) {
+        j["print"]["command"] = "back_to_center";
+        return publish(dev_id, j, lan_mode);
+    }
+
+    j["print"]["command"] = "gcode_line";
+    j["print"]["param"] = is_printing ? "G28 X\n" : "G28 \n";
+    return publish(dev_id, j, lan_mode);
+}
+
+int BBLPrinterAgent::command_set_bed(std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode)
+{
+    nlohmann::json j;
+    j["print"]["sequence_id"] = std::to_string(sequence_id);
+    if (supports_mqtt_bed_ctrl) {
+        j["print"]["command"] = "set_bed_temp";
+        j["print"]["temp"] = temp;
+        return publish(dev_id, j, lan_mode);
+    }
+
+    j["print"]["command"] = "gcode_line";
+    j["print"]["param"] = (boost::format("M140 S%1%\n") % temp).str();
+    return publish(dev_id, j, lan_mode);
+}
+
+int BBLPrinterAgent::command_set_nozzle(std::string dev_id, int temp, int sequence_id, bool lan_mode)
+{
+    nlohmann::json j;
+    j["print"]["command"] = "gcode_line";
+    j["print"]["param"] = (boost::format("M104 S%1%\n") % temp).str();
+    j["print"]["sequence_id"] = std::to_string(sequence_id);
+    return publish(dev_id, j, lan_mode);
+}
+
+int BBLPrinterAgent::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)
+{
+    nlohmann::json j;
+    j["print"]["sequence_id"] = std::to_string(sequence_id);
+
+    if (supports_mqtt_axis_control) {
+        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")) {
+            dir = -dir;
+        }
+
+        j["print"]["command"] = "xyz_ctrl";
+        j["print"]["axis"] = axis;
+        j["print"]["dir"] = dir;
+        j["print"]["mode"] = (std::abs(input_val) >= 10) ? 1 : 0;
+        return publish(dev_id, j, lan_mode);
+    }
+
+    double value = input_val;
+    if (!is_core_xy && (axis == "Y" || axis == "Z")) {
+        value = -1.0 * input_val;
+    }
+
+    std::string value_str = (boost::format("%.1f") % (value * unit)).str();
+    std::string gcode;
+    if (axis == "X" || axis == "Y" || axis == "Z") {
+        gcode = (boost::format("M211 S \nM211 X1 Y1 Z1\nM1002 push_ref_mode\nG91 \nG1 %1%%2% F%3%\nM1002 pop_ref_mode\nM211 R\n")
+                 % axis % value_str % speed).str();
+    } else if (axis == "E") {
+        gcode = (boost::format("M83 \nG0 %1%%2% F%3%\n") % axis % value_str % speed).str();
+    } else {
+        return -1;
+    }
+
+    j["print"]["command"] = "gcode_line";
+    j["print"]["param"] = gcode;
+    return publish(dev_id, j, lan_mode);
+}
+
+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) {
+        BOOST_LOG_TRIVIAL(info) << "publish_json: " << j.dump() << " code: " << rtn;
+    } else {
+        BOOST_LOG_TRIVIAL(error) << "publish_json: " << j.dump() << " code: " << rtn;
+    }
+    return rtn;
+}
+
 int BBLPrinterAgent::send_message(std::string dev_id, std::string json_str, int qos, int flag)
 {
     json_str = from_orca_payload(std::move(json_str));
@@ -473,8 +637,15 @@ int BBLPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateS
 
 int BBLPrinterAgent::start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
 {
-    return dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
+    int result = dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
         BBLNetworkPlugin::instance().get_start_send_gcode_to_sdcard(), params, update_fn, cancel_fn, wait_fn);
+    if (result != 0) {
+        BOOST_LOG_TRIVIAL(error) << "start_send_gcode_to_sdcard failed: result=" << result
+            << ", try_emmc_print=" << params.try_emmc_print
+            << ", legacy_mode=" << BBLNetworkPlugin::instance().use_legacy_network()
+            << ", dev_ip=" << params.dev_ip << ", dev_id=" << params.dev_id;
+    }
+    return result;
 }
 
 int BBLPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)

src/slic3r/Utils/BBLPrinterAgent.hpp

@@ -5,6 +5,7 @@
 #include "ICloudServiceAgent.hpp"
 #include <string>
 #include <memory>
+#include <nlohmann/json.hpp>
 
 namespace Slic3r {
 
@@ -28,9 +29,23 @@ public:
 
     // Communication
     int send_message(std::string dev_id, std::string json_str, int qos, int flag) override;
+    static std::string ams_refresh_rfid_gcode(const std::string& tray_id);
+    static std::string ams_calibrate_gcode(int ams_id);
+    static std::string ams_select_tray_gcode(const std::string& tray_id);
+    int command_ams_refresh_rfid(std::string dev_id, std::string 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_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;
     int connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl) override;
     int disconnect_printer() override;
     int send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag) override;
+    std::string default_lan_username() const override { return "bblp"; }
 
     // Certificates
     int check_cert() override;
@@ -99,7 +114,8 @@ public:
     static std::string from_orca_payload(std::string json_text);
 
 private:
-    std::shared_ptr<ICloudServiceAgent> m_cloud_agent;
+    // 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);
 };
 
 } // namespace Slic3r

src/slic3r/Utils/CrealityPrintAgent.cpp

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

src/slic3r/Utils/CrealityPrintAgent.hpp

@@ -1,6 +1,7 @@
 #ifndef __CREALITY_PRINT_AGENT_HPP__
 #define __CREALITY_PRINT_AGENT_HPP__
 
+#include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 
 #include <string>
@@ -41,7 +42,7 @@ public:
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
-    bool fetch_filament_info(std::string dev_id) override;
+    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
     // Parse the boxsInfo JSON returned by CrealityPrint::query_boxes_info() into
     // a flat list of loaded slots, plus the count of CFS boxes the printer reports.

src/slic3r/Utils/FileTransferUtils.cpp

@@ -224,4 +224,4 @@ void FileTransferJob::solve_result(ft_job_result result)
     res_json_.assign(result.json ? result.json : "");
 }
 
-} // namespace Slic3r
+} // namespace Slic3r

src/slic3r/Utils/FileTransferUtils.hpp

@@ -252,4 +252,4 @@ inline FileTransferModule &module()
     return *detail::g_mod;
 }
 
-} // namespace Slic3r
+} // namespace Slic3r

src/slic3r/Utils/ICameraSignalingChannel.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace Slic3r {
+
+struct CameraIceServer {
+    std::string urls;
+    std::string username;
+    std::string credential;
+};
+
+enum class CameraUnavailableReason {
+    Busy,
+    Error,
+    Disabled,
+    Closed,
+};
+
+class ICameraSignalingChannel {
+public:
+    virtual ~ICameraSignalingChannel() = default;
+
+    virtual void open() = 0;
+    virtual void close() = 0;
+    virtual void send_offer(std::string sdp) = 0;
+    virtual void send_ice(std::string candidate, std::string mid) = 0;
+
+    // These callbacks are invoked by the channel's worker thread. Consumers
+    // must marshal UI work to the GUI thread themselves.
+    std::function<void(std::vector<CameraIceServer>)> on_ready;
+    std::function<void(std::string)> on_answer;
+    std::function<void(std::string, std::string)> on_ice;
+    std::function<void(CameraUnavailableReason, std::string)> on_unavailable;
+};
+
+} // namespace Slic3r

src/slic3r/Utils/IPrinterAgent.hpp

@@ -11,6 +11,10 @@
 #define ORCA_NETWORK_ERR_CAP_NOT_AVAILABLE -7020 // a translation exists; this printer lacks the capability
 #include <string>
 #include <memory>
+#include <vector>
+#include <functional>
+#include <cstdint>
+#include "ICameraSignalingChannel.hpp"
 
 namespace Slic3r {
 
@@ -43,6 +47,15 @@ enum class FilamentSyncMode {
     pull          ///< On-demand fetch via REST API (blocking call)
 };
 
+enum class CameraStreamMode {
+    none = 0,
+    http,  // LAN or Cloud
+    https, // LAN or Cloud over TLS
+    rtsp,  // LAN only
+    webrtc, // Cloud only
+    http_snapshot // HTTP endpoint returning one image per request
+};
+
 /**
  * IPrinterAgent - Interface for printer operations.
  *
@@ -84,6 +97,38 @@ public:
      */
     virtual int send_message(std::string dev_id, std::string json_str, int qos, int flag) = 0;
 
+    // why: gcode is firmware dialect, not a waist concept - commands whose body is Bambu-dialect
+    // gcode live on the agent that speaks it; the default is an honest refusal that MachineObject's
+    // publish funnel turns into a dialog.
+    virtual int command_ams_refresh_rfid(std::string, std::string, int, bool)
+    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
+    virtual int command_ams_calibrate(std::string, int, int, bool)
+    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
+    virtual int command_ams_select_tray(std::string, std::string, int, bool)
+    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
+    virtual int command_start_camera(std::string)
+    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
+
+    virtual int command_xyz_abs(std::string dev_id, int sequence_id, bool lan_mode)
+    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
+    virtual int command_auto_leveling(std::string dev_id, int sequence_id, bool lan_mode)
+    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
+    virtual int command_go_home(std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode)
+    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
+    virtual int command_set_bed(std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode)
+    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
+    virtual int command_set_nozzle(std::string dev_id, int temp, int sequence_id, bool lan_mode)
+    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
+    virtual 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)
+    { return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED; }
+
+    /**
+     * Default LAN account username for this agent's protocol, if it has a fixed one.
+     * Returns an empty string if the agent has no fixed default (e.g. caller must supply one).
+     */
+    virtual std::string default_lan_username() const { return {}; }
+
     /**
      * Establish a direct LAN connection to a printer.
      */
@@ -105,12 +150,16 @@ public:
     /**
      * Validate current user certificates for the printer.
      */
-    virtual int check_cert() = 0;
+    virtual int check_cert() { return BAMBU_NETWORK_SUCCESS; }
 
     /**
      * Install or refresh device certificate for LAN TLS.
      */
-    virtual void install_device_cert(std::string dev_id, bool lan_only) = 0;
+    virtual void install_device_cert(std::string dev_id, bool lan_only)
+    {
+        (void) dev_id;
+        (void) lan_only;
+    }
 
     // ========================================================================
     // Discovery
@@ -126,7 +175,11 @@ public:
     /**
      * Ping the binding endpoint to check printer readiness.
      */
-    virtual int ping_bind(std::string ping_code) = 0;
+    virtual int ping_bind(std::string ping_code)
+    {
+        (void) ping_code;
+        return BAMBU_NETWORK_SUCCESS;
+    }
 
     /**
      * Perform binding detection/handshake on a LAN printer.
@@ -136,23 +189,50 @@ public:
     /**
      * Execute the multi-stage printer binding workflow.
      */
-    virtual int bind(std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn) = 0;
+    virtual int bind(std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link,
+                     std::string timezone, bool improved, OnUpdateStatusFn update_fn)
+    {
+        (void) dev_ip;
+        (void) dev_id;
+        (void) dev_model;
+        (void) sec_link;
+        (void) timezone;
+        (void) improved;
+        (void) update_fn;
+        return BAMBU_NETWORK_SUCCESS;
+    }
 
     /**
      * Remove the association between account and printer.
      */
-    virtual int unbind(std::string dev_id) = 0;
+    virtual int unbind(std::string dev_id)
+    {
+        (void) dev_id;
+        return BAMBU_NETWORK_SUCCESS;
+    }
 
     /**
      * Request a one-time bind ticket from the server.
      */
-    virtual int request_bind_ticket(std::string* ticket) = 0;
+    virtual int request_bind_ticket(std::string* ticket)
+    {
+        if (ticket)
+            *ticket = {};
+        return BAMBU_NETWORK_SUCCESS;
+    }
 
     /**
      * Fetch the cloud snapshot image captured at a print failure.
      * Returns 0 if the request was dispatched; the image body arrives via callback(body, http_status).
      */
-    virtual int get_hms_snapshot(std::string dev_id, std::string file_name, std::function<void(std::string, int)> callback) = 0;
+    virtual int get_hms_snapshot(std::string dev_id, std::string file_name,
+                                 std::function<void(std::string, int)> callback)
+    {
+        (void) dev_id;
+        (void) file_name;
+        (void) callback;
+        return -1;
+    }
 
     /**
      * Register callback for fatal HTTP errors.
@@ -168,7 +248,7 @@ public:
     virtual std::string get_user_selected_machine() = 0;
 
     /**
-     * Update the selected machine preference.
+     * Update the selected cloud machine preference.
      */
     virtual int set_user_selected_machine(std::string dev_id) = 0;
 
@@ -284,12 +364,20 @@ public:
      */
     virtual FilamentSyncMode get_filament_sync_mode() const { return FilamentSyncMode::none; }
 
+    /**
+     * Get the camera stream mode for this agent. This value can be deterministic and derived at
+     * runtime if the printer supports multiple camera stream modes. E.g. LAN => HTTP/HTTPS/RTSP, Cloud => WebRTC.
+     *
+     * @return CameraStreamMode indicating how the camera stream is obtained or used:
+     */
+    virtual CameraStreamMode get_camera_stream_mode() const { return CameraStreamMode::none; }
+
     /**
      * Refresh filament info from the printer synchronously.
      * Should only be called when get_filament_sync_mode() returns FilamentSyncMode::pull.
      * Populates the MachineObject's DevFilaSystem with fetched filament data.
      */
-    virtual bool fetch_filament_info(std::string dev_id) { return false; }
+    virtual bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) { return false; }
 
     /**
      * Translate one filament id across the printer boundary.
@@ -300,6 +388,21 @@ public:
      */
     virtual std::string to_orca_filament_id(const std::string& printer_filament_id) const { return printer_filament_id; }
     virtual std::string from_orca_filament_id(const std::string& orca_filament_id) const { return orca_filament_id; }
+
+    /**
+     * Get the current camera stream URL for this agent's active machine.
+     * Only meaningful when get_camera_stream_mode() returns an HTTP, HTTPS, or RTSP mode.
+     */
+    virtual std::string get_camera_url() const { return {}; }
+
+    // Optional native camera signaling. Plugin agents retain the default
+    // nullptr until a plugin-facing WebRTC contract is defined.
+    virtual std::unique_ptr<ICameraSignalingChannel>
+    create_camera_signaling_channel(const std::string& dev_id)
+    {
+        (void) dev_id;
+        return nullptr;
+    }
 };
 
 } // namespace Slic3r

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -3,17 +3,23 @@
 
 #include "IPrinterAgent.hpp"
 #include "ICloudServiceAgent.hpp"
+#include "AmsPayload.hpp"
 
 #include <memory>
 #include <mutex>
 #include <set>
 #include <string>
 #include <thread>
+#include <condition_variable>
+#include <deque>
+#include <functional>
 
 #include <nlohmann/json.hpp>
 
 namespace Slic3r {
 
+bool moonraker_is_light_name(const std::string& name);
+
 class MoonrakerPrinterAgent : public IPrinterAgent
 {
 public:
@@ -32,20 +38,11 @@ public:
     int disconnect_printer() override;
     int send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag) override;
 
-    // Certificates
-    int check_cert() override;
-    void install_device_cert(std::string dev_id, bool lan_only) override;
-
     // Discovery
     bool start_discovery(bool start, bool sending) override;
 
     // Binding
-    int ping_bind(std::string ping_code) override;
     int bind_detect(std::string dev_ip, std::string sec_link, detectResult& detect) override;
-    int bind(std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn) override;
-    int unbind(std::string dev_id) override;
-    int request_bind_ticket(std::string* ticket) override;
-    int get_hms_snapshot(std::string dev_id, std::string file_name, std::function<void(std::string, int)> callback) override;
     int set_server_callback(OnServerErrFn fn) override;
 
     // Machine Selection
@@ -68,10 +65,9 @@ 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) override;
+    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
+    CameraStreamMode get_camera_stream_mode() const override;
+    std::string get_camera_url() const override;
 
 protected:
     struct MoonrakerDeviceInfo
@@ -85,30 +81,31 @@ protected:
         std::string dev_name;
         std::string version;
         std::string klippy_state;
+        float       nozzle_diameter = 0.0f;
         bool        use_ssl = false;
     } device_info;
 
-    // Tray data for AMS payload building
-    struct AmsTrayData {
-        int         slot_index = 0;      // 0-based slot index
-        bool        has_filament = false;
-        std::string tray_type;           // Material type (e.g., "PLA", "ASA")
-        std::string tray_color;          // Raw color (#RRGGBB, 0xRRGGBB, or RRGGBBAA)
-        std::string tray_info_idx;       // Setting ID (optional)
-        int         bed_temp = 0;        // Optional
-        int         nozzle_temp = 0;     // Optional
-    };
-
-    // Build ams JSON and call parser
+    // Build ams JSON and call parser (AmsTrayData is shared; see AmsPayload.hpp).
     void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
+    // Overload for agents with vendor-aware matching (Snapmaker): the resolver
+    // runs on the main thread inside the shared builder, preserving the match
+    // without touching preset state on the fetch worker.
+    void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays, const TrayInfoResolver& vendor_resolver);
 
     // Methods that derived classes may need to override or access
     virtual bool init_device_info(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl);
     virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
+    static float parse_nozzle_diameter(const nlohmann::json& response);
 
     // 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(std::string host, const std::string& port);
@@ -118,8 +115,17 @@ protected:
     // Trim whitespace and convert to uppercase
     static std::string trim_and_upper(const std::string& input);
 
-    // 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 std::string& base_url, const std::string& api_key) const;
+    bool post_print_action(const std::string& action) const;
+    bool post_print_action(const std::string& action,
+                           const std::string& base_url, const std::string& api_key) const;
+
+    bool send_ws_rpc(const std::string& method, const nlohmann::json& params);
+
+    virtual void on_status_loop_tick(const std::string& dev_id) {}
 
 private:
     int handle_request(const std::string& dev_id, const std::string& json_str);
@@ -128,7 +134,6 @@ private:
 
     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(const std::string& dev_id, const std::string& gcode) const;
 
     void announce_printhost_device();
     void dispatch_local_connect(int state, const std::string& dev_id, const std::string& msg);
@@ -137,7 +142,8 @@ private:
     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, std::string base_url, std::string api_key);
-    void handle_ws_message(const std::string& dev_id, const std::string& payload);
+    void handle_ws_message(std::string dev_id, std::string payload, std::string base_url, std::string api_key);
+    void refresh_thumbnail_url(std::string base_url, std::string api_key);
     void update_status_cache(const nlohmann::json& updates);
     nlohmann::json build_print_payload_locked() const;
 
@@ -151,9 +157,10 @@ private:
                       const std::string& base_url, const std::string& api_key,
                       OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
 
-    // JSON-RPC helper
-    bool send_jsonrpc_command(const std::string& base_url, const std::string& api_key,
-                              const nlohmann::json& request, std::string& response) const;
+    // Start a print of a previously uploaded G-code file (path relative to the
+    // Moonraker gcodes root).
+    bool start_print_file(const std::string& base_url, const std::string& api_key,
+                          const std::string& filename, std::string& error_msg) const;
 
     // Connection thread management
     void perform_connection_async(const std::string& dev_id,
@@ -161,16 +168,19 @@ private:
                                    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 std::string& base_url, const std::string& api_key, uint64_t generation) const;
+
     // System-specific filament fetch methods
     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);
-    static int safe_json_int(const nlohmann::json& obj, const char* key);
     static std::string safe_array_string(const nlohmann::json& arr, int idx);
     static int safe_array_int(const nlohmann::json& arr, int idx);
-    static std::string normalize_color_value(const std::string& color);
 
     std::string                        ssdp_announced_host;
     std::string                        ssdp_announced_id;
@@ -189,15 +199,38 @@ 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
@@ -207,7 +240,15 @@ private:
     // Connection thread management
     std::atomic<uint64_t>  connect_generation{0};
     std::thread            connect_thread;
-    std::recursive_mutex   connect_mutex;
+    mutable std::recursive_mutex connect_mutex;
+
+    void enqueue_command(std::function<void()> fn);
+    void run_command_worker();
+    std::thread cmd_thread;
+    std::deque<std::function<void()>> cmd_queue;
+    std::mutex cmd_mutex;
+    std::condition_variable cmd_cv;
+    bool cmd_stop = false;
 };
 
 } // namespace Slic3r

src/slic3r/Utils/NetworkAgent.cpp

@@ -4,6 +4,8 @@
 #include <algorithm>
 
 #include <boost/log/trivial.hpp>
+#include <nlohmann/json.hpp>
+#include "IPrinterAgent.hpp"
 #include "libslic3r/Utils.hpp"
 #include "NetworkAgent.hpp"
 #include "BBLNetworkPlugin.hpp"
@@ -115,6 +117,8 @@ void NetworkAgent::add_cloud_agent(const std::string& provider, std::shared_ptr<
 
 void NetworkAgent::set_printer_agent(std::shared_ptr<IPrinterAgent> printer_agent)
 {
+    m_user_machine_list_generation.fetch_add(1);
+
     // Disconnect all callbacks from the old agent
     auto old_printer_agent = m_printer_agent;
 
@@ -432,10 +436,26 @@ int NetworkAgent::check_user_task_report(int* task_id, bool* printable, const st
 
 int NetworkAgent::get_user_print_info(unsigned int* http_code, std::string* http_body, const std::string& provider)
 {
+    const std::string request_agent_id = m_printer_agent_id;
+    const std::uint64_t request_generation = m_user_machine_list_generation.fetch_add(1) + 1;
     const auto cloud_agent = get_cloud_agent(provider);
-    if (cloud_agent)
-        return cloud_agent->get_user_print_info(http_code, http_body);
-    return -1;
+    if (!cloud_agent)
+        return -1;
+
+    const int result = cloud_agent->get_user_print_info(http_code, http_body);
+    if (result == 0 && http_body) {
+        try {
+            nlohmann::json response = nlohmann::json::parse(*http_body);
+            response["provider"] = provider;
+            response["agent_id"] = request_agent_id;
+            response["generation"] = request_generation;
+            *http_body = response.dump();
+        }
+        catch (const std::exception& e) {
+            BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << " metadata injection exception=" << e.what();
+        }
+    }
+    return result;
 }
 
 int NetworkAgent::get_user_tasks(TaskQueryParams params, std::string* http_body, const std::string& provider)
@@ -767,6 +787,77 @@ int NetworkAgent::send_message(std::string dev_id, std::string json_str, int qos
     return -1;
 }
 
+int NetworkAgent::command_ams_refresh_rfid(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode)
+{
+    if (m_printer_agent)
+        return m_printer_agent->command_ams_refresh_rfid(dev_id, tray_id, sequence_id, lan_mode);
+    return -1;
+}
+
+int NetworkAgent::command_ams_calibrate(std::string dev_id, int ams_id, int sequence_id, bool lan_mode)
+{
+    if (m_printer_agent)
+        return m_printer_agent->command_ams_calibrate(dev_id, ams_id, sequence_id, lan_mode);
+    return -1;
+}
+
+int NetworkAgent::command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode)
+{
+    if (m_printer_agent)
+        return m_printer_agent->command_ams_select_tray(dev_id, tray_id, sequence_id, lan_mode);
+    return -1;
+}
+
+int NetworkAgent::command_start_camera(std::string dev_id)
+{
+    if (m_printer_agent)
+        return m_printer_agent->command_start_camera(dev_id);
+    return -1;
+}
+
+int NetworkAgent::command_xyz_abs(std::string dev_id, int sequence_id, bool lan_mode)
+{
+    if (m_printer_agent)
+        return m_printer_agent->command_xyz_abs(dev_id, sequence_id, lan_mode);
+    return -1;
+}
+
+int NetworkAgent::command_auto_leveling(std::string dev_id, int sequence_id, bool lan_mode)
+{
+    if (m_printer_agent)
+        return m_printer_agent->command_auto_leveling(dev_id, sequence_id, lan_mode);
+    return -1;
+}
+
+int NetworkAgent::command_go_home(std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode)
+{
+    if (m_printer_agent)
+        return m_printer_agent->command_go_home(dev_id, is_printing, supports_mqtt_homing, sequence_id, lan_mode);
+    return -1;
+}
+
+int NetworkAgent::command_set_bed(std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode)
+{
+    if (m_printer_agent)
+        return m_printer_agent->command_set_bed(dev_id, temp, supports_mqtt_bed_ctrl, sequence_id, lan_mode);
+    return -1;
+}
+
+int NetworkAgent::command_set_nozzle(std::string dev_id, int temp, int sequence_id, bool lan_mode)
+{
+    if (m_printer_agent)
+        return m_printer_agent->command_set_nozzle(dev_id, temp, sequence_id, lan_mode);
+    return -1;
+}
+
+int NetworkAgent::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)
+{
+    if (m_printer_agent)
+        return m_printer_agent->command_axis_control(dev_id, axis, unit, input_val, speed, is_core_xy, supports_mqtt_axis_control, sequence_id, lan_mode);
+    return -1;
+}
+
 int NetworkAgent::connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl)
 {
     if (m_printer_agent)
@@ -788,6 +879,13 @@ int NetworkAgent::send_message_to_printer(std::string dev_id, std::string json_s
     return -1;
 }
 
+std::string NetworkAgent::default_lan_username() const
+{
+    if (m_printer_agent)
+        return m_printer_agent->default_lan_username();
+    return {};
+}
+
 int NetworkAgent::check_cert()
 {
     if (m_printer_agent)
@@ -846,8 +944,14 @@ std::string NetworkAgent::get_user_selected_machine()
 
 int NetworkAgent::set_user_selected_machine(std::string dev_id)
 {
-    if (m_printer_agent)
-        return m_printer_agent->set_user_selected_machine(dev_id);
+    BOOST_LOG_TRIVIAL(info) << "NetworkAgent::set_user_selected_machine: dev_id=" << dev_id
+                            << " printer_agent=" << (m_printer_agent ? m_printer_agent->get_agent_info().id : "<null>");
+    if (m_printer_agent) {
+        const int result = m_printer_agent->set_user_selected_machine(dev_id);
+        BOOST_LOG_TRIVIAL(info) << "NetworkAgent::set_user_selected_machine: result=" << result;
+        return result;
+    }
+    BOOST_LOG_TRIVIAL(warning) << "NetworkAgent::set_user_selected_machine: no printer agent";
     return -1;
 }
 
@@ -867,15 +971,27 @@ int NetworkAgent::stop_subscribe(std::string module)
 
 int NetworkAgent::add_subscribe(std::vector<std::string> dev_list)
 {
-    if (m_printer_agent)
-        return m_printer_agent->add_subscribe(std::move(dev_list));
+    BOOST_LOG_TRIVIAL(info) << "NetworkAgent::add_subscribe: count=" << dev_list.size()
+                            << " printer_agent=" << (m_printer_agent ? m_printer_agent->get_agent_info().id : "<null>");
+    if (m_printer_agent) {
+        const int result = m_printer_agent->add_subscribe(std::move(dev_list));
+        BOOST_LOG_TRIVIAL(info) << "NetworkAgent::add_subscribe: result=" << result;
+        return result;
+    }
+    BOOST_LOG_TRIVIAL(warning) << "NetworkAgent::add_subscribe: no printer agent";
     return -1;
 }
 
 int NetworkAgent::del_subscribe(std::vector<std::string> dev_list)
 {
-    if (m_printer_agent)
-        return m_printer_agent->del_subscribe(std::move(dev_list));
+    BOOST_LOG_TRIVIAL(info) << "NetworkAgent::del_subscribe: count=" << dev_list.size()
+                            << " printer_agent=" << (m_printer_agent ? m_printer_agent->get_agent_info().id : "<null>");
+    if (m_printer_agent) {
+        const int result = m_printer_agent->del_subscribe(std::move(dev_list));
+        BOOST_LOG_TRIVIAL(info) << "NetworkAgent::del_subscribe: result=" << result;
+        return result;
+    }
+    BOOST_LOG_TRIVIAL(warning) << "NetworkAgent::del_subscribe: no printer agent";
     return -1;
 }
 
@@ -921,10 +1037,10 @@ FilamentSyncMode NetworkAgent::get_filament_sync_mode() const
     return FilamentSyncMode::none;
 }
 
-bool NetworkAgent::fetch_filament_info(std::string dev_id)
+bool NetworkAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
 {
     if (m_printer_agent) {
-        return m_printer_agent->fetch_filament_info(dev_id);
+        return m_printer_agent->fetch_filament_info(dev_id, sync_mode);
     }
     return false;
 }
@@ -943,6 +1059,28 @@ std::string NetworkAgent::from_orca_filament_id(const std::string& orca_filament
     return orca_filament_id;
 }
 
+CameraStreamMode NetworkAgent::get_camera_stream_mode() const
+{
+    if (m_printer_agent)
+        return m_printer_agent->get_camera_stream_mode();
+    return CameraStreamMode::none;
+}
+
+std::string NetworkAgent::get_local_camera_stream_url() const
+{
+    if (m_printer_agent)
+        return m_printer_agent->get_camera_url();
+    return {};
+}
+
+std::unique_ptr<ICameraSignalingChannel>
+NetworkAgent::create_camera_signaling_channel(const std::string& dev_id)
+{
+    if (m_printer_agent)
+        return m_printer_agent->create_camera_signaling_channel(dev_id);
+    return nullptr;
+}
+
 int NetworkAgent::request_bind_ticket(std::string* ticket)
 {
     if (m_printer_agent)

src/slic3r/Utils/NetworkAgent.hpp

@@ -2,16 +2,22 @@
 #define __NETWORK_Agent_HPP__
 
 #include "bambu_networking.hpp"
+
 #include "libslic3r/ProjectTask.hpp"
 #include "ICloudServiceAgent.hpp"
 #include "IPrinterAgent.hpp"
+
 #include <map>
+#include <atomic>
+#include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace Slic3r {
 
+class IPrinterAgent;
+
 // Forward declaration
 class BBLNetworkPlugin;
 
@@ -50,6 +56,7 @@ public:
     // Sub-agent accessors
     std::shared_ptr<ICloudServiceAgent> get_cloud_agent(const std::string& provider = ORCA_CLOUD_PROVIDER) const;
     std::shared_ptr<IPrinterAgent> get_printer_agent() const { return m_printer_agent; }
+    std::uint64_t get_user_machine_list_generation() const { return m_user_machine_list_generation.load(); }
 
     // Shared agent management
     void add_cloud_agent(const std::string& provider, std::shared_ptr<ICloudServiceAgent> agent);
@@ -142,9 +149,21 @@ public:
     int set_on_local_message_fn(OnMessageFn fn);
     int set_server_callback(OnServerErrFn fn);
     int send_message(std::string dev_id, std::string json_str, int qos, int flag);
+    int command_ams_refresh_rfid(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode);
+    int command_ams_calibrate(std::string dev_id, int ams_id, int sequence_id, bool lan_mode);
+    int command_ams_select_tray(std::string dev_id, std::string tray_id, int sequence_id, bool lan_mode);
+    int command_start_camera(std::string dev_id);
+    int command_xyz_abs(std::string dev_id, int sequence_id, bool lan_mode);
+    int command_auto_leveling(std::string dev_id, int sequence_id, bool lan_mode);
+    int command_go_home(std::string dev_id, bool is_printing, bool supports_mqtt_homing, int sequence_id, bool lan_mode);
+    int command_set_bed(std::string dev_id, int temp, bool supports_mqtt_bed_ctrl, int sequence_id, bool lan_mode);
+    int command_set_nozzle(std::string dev_id, int temp, int sequence_id, bool lan_mode);
+    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);
     int connect_printer(std::string dev_id, std::string dev_ip, std::string username, std::string password, bool use_ssl);
     int disconnect_printer();
     int send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag);
+    std::string default_lan_username() const;
     int check_cert();
     void install_device_cert(std::string dev_id, bool lan_only);
     bool start_discovery(bool start, bool sending);
@@ -164,7 +183,10 @@ public:
     int start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
     int start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
     FilamentSyncMode get_filament_sync_mode() const;
-    bool fetch_filament_info(std::string dev_id);
+    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull);
+    CameraStreamMode get_camera_stream_mode() const;
+    std::string get_local_camera_stream_url() const;
+    std::unique_ptr<ICameraSignalingChannel> create_camera_signaling_channel(const std::string& dev_id);
     std::string to_orca_filament_id(const std::string& printer_filament_id) const;
     std::string from_orca_filament_id(const std::string& orca_filament_id) const;
     int request_bind_ticket(std::string* ticket);
@@ -195,6 +217,7 @@ private:
     std::map<std::string, std::shared_ptr<ICloudServiceAgent>> m_cloud_agents;
     std::shared_ptr<IPrinterAgent> m_printer_agent;
     std::string m_printer_agent_id;
+    std::atomic<std::uint64_t> m_user_machine_list_generation{0};
 };
 
 }

src/slic3r/Utils/NetworkAgentFactory.cpp

@@ -16,8 +16,10 @@
 #include <mutex>
 #include <utility>
 #include <slic3r/GUI/GUI_App.hpp>
+#include <slic3r/GUI/I18N.hpp>
 #include <slic3r/plugin/PluginDescriptor.hpp>
 #include <slic3r/plugin/PythonPluginInterface.hpp>
+#include <wx/msgdlg.h>
 
 namespace Slic3r {
 namespace {
@@ -314,6 +316,21 @@ void NetworkAgentFactory::register_python_printer_agent(const std::string& plugi
 
     std::shared_ptr<IPrinterAgent> cached_agent;
 
+    auto reject_conflicting_capability = [plugin_key, capability_name](const std::string& error_message) {
+        if (!wxTheApp || GUI::wxGetApp().is_closing())
+            return;
+        GUI::wxGetApp().CallAfter([plugin_key, capability_name, error_message]() {
+            if (GUI::wxGetApp().is_closing())
+                return;
+            PluginManager& manager = PluginManager::instance();
+            manager.set_plugin_error(plugin_key, error_message);
+            // note: the unload callback triggered by disabling will call deregister,
+            // which will be a no-op since the printer agent is never registered
+            manager.set_capability_enabled({PluginCapabilityType::PrinterConnection, capability_name, plugin_key}, false);
+            wxMessageBox(wxString::FromUTF8(error_message.c_str()), _L("Plugins"), wxOK | wxICON_WARNING, GUI::wxGetApp().GetTopWindow());
+        });
+    };
+
     {
         std::lock_guard<std::mutex> lock(s_registry_mutex);
 
@@ -332,9 +349,10 @@ void NetworkAgentFactory::register_python_printer_agent(const std::string& plugi
         auto& python_agent_ids = get_python_printer_agent_ids();
         for (const auto& pair : python_agent_ids) {
             if (pair.first != capability_key && pair.second == info.id) {
-                BOOST_LOG_TRIVIAL(warning) << "Printer-agent plugin '" << capability_name << "' uses duplicate agent ID '" << info.id
-                                           << "' already registered by capability '" << pair.first.second << "' from plugin '"
-                                           << pair.first.first << "'";
+                const std::string error_message = "Printer-agent '" + info.name + "' could not be enabled: agent ID '" + info.id +
+                                                  "' is already registered by capability '" + pair.first.second + "' from plugin '" + pair.first.first + "'.";
+                BOOST_LOG_TRIVIAL(warning) << error_message;
+                reject_conflicting_capability(error_message);
                 return;
             }
         }
@@ -354,12 +372,22 @@ void NetworkAgentFactory::register_python_printer_agent(const std::string& plugi
 
         auto& agents = get_printer_agents();
         auto agent_it = agents.find(info.id);
+        // why: reject only when the ID is owned by SOMEONE ELSE - a built-in has an empty
+        //   plugin_identifier, another plugin/capability has a different plugin_full_ref. When it
+        //   IS the same plugin_full_ref, this capability is just re-registering itself, so fall
+        //   through and refresh.
         if (agent_it != agents.end() && agent_it->second.plugin_identifier != plugin_full_ref) {
-            BOOST_LOG_TRIVIAL(warning) << "Printer-agent plugin '" << capability_name << "' uses agent ID '" << info.id
-                                       << "' already registered by '" << agent_it->second.display_name << "'";
+            const std::string error_message = "Printer-agent '" + info.name + "' could not be enabled: agent ID '" + info.id +
+                                              "' is already registered by '" + agent_it->second.display_name + "'.";
+            BOOST_LOG_TRIVIAL(warning) << error_message;
+            reject_conflicting_capability(error_message);
             return;
         }
 
+        // why: insert_or_assign, not emplace - reaching here means the ID is new, or the same
+        //   capability is re-registering (same plugin_full_ref). In the re-register case we WANT to
+        //   overwrite so the factory closure points at the current live capability instance; emplace
+        //   would silently keep the stale entry.
         agents.insert_or_assign(info.id, PrinterAgentInfo(info.id, info.name, plugin_full_ref, std::move(factory)));
         python_agent_ids[capability_key] = info.id;
 

src/slic3r/Utils/OrcaCloudServiceAgent.cpp

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

src/slic3r/Utils/OrcaCloudServiceAgent.hpp

@@ -2,6 +2,12 @@
 #define __ORCA_CLOUD_SERVICE_AGENT_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>
@@ -9,12 +15,17 @@
 #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 {
@@ -206,6 +217,19 @@ public:
     int add_subscribe(std::vector<std::string> dev_list) override;
     int del_subscribe(std::vector<std::string> dev_list) override;
     void enable_multi_machine(bool enable) override;
+    int set_printer_status_callback(OnMessageFn fn);
+    int send_printer_command(const std::string& dev_id, const std::string& body);
+
+    int upload_gcode_via_cloud(const std::string& dev_id,
+                               const std::string& local_gcode_path,
+                               std::string* job_id,
+                               OnUpdateStatusFn update_fn,
+                               WasCancelledFn cancel_fn);
+
+    int start_cloud_print_job(const std::string& dev_id,
+                              const std::string& job_id,
+                              const std::string& filename,
+                              bool start = true);
 
     // ========================================================================
     // ICloudServiceAgent Interface Implementation - Settings Synchronization
@@ -346,7 +370,29 @@ public:
 
     static std::string generate_uuid_for_setting_id(const std::string& name, const std::string& user_id = "");
 
+    OrcaMqttConnection* get_mqtt_connection() noexcept {
+        return mqtt_connection.get();
+    }
+
+    const OrcaMqttConnection* get_mqtt_connection() const noexcept {
+        return mqtt_connection.get();
+    }
+
+    // Account-scoped cloud socket: wss://<api_base_url>/api/v1/printers/mqtt.
+    // configure_ blocks for the duration of the initial connect attempt, so callers
+    // drive it off the UI thread; teardown_ is synchronous. The dev_id argument is
+    // retained for source compatibility with the printer-agent lifecycle; it does
+    // not participate in endpoint construction.
+    int         configure_selected_printer_mqtt(const std::string& dev_id,
+                                                OrcaMqttConnection::StateHandler state_handler = {});
+    void        teardown_selected_printer_mqtt();
+    // Test hook: the wss:// URL of the current fleet socket ("" when none).
+    std::string selected_printer_mqtt_url() const;
+
 private:
+    // Fans one inbound fleet MQTT message out to printer_status_callback.
+    void deliver_cloud_message(const std::string& dev_id, const std::string& payload);
+
     // Sync protocol helpers
     int sync_pull(
         std::function<void(const SyncPullResponse&)> on_success,
@@ -370,7 +416,11 @@ private:
 
     // HTTP request helpers
     int http_get(const std::string& path, std::string* response_body, unsigned int* http_code);
-    int http_post(const std::string& path, const std::string& body, std::string* response_body, unsigned int* http_code);
+    int http_post(const std::string& path,
+                  const std::string& body,
+                  std::string* response_body,
+                  unsigned int* http_code,
+                  const std::string& content_type = "application/json");
     int http_put(const std::string& path, const std::string& body, std::string* response_body, unsigned int* http_code);
     int http_delete(const std::string& path, std::string* response_body, unsigned int* http_code);
     std::map<std::string, std::string> data_headers();
@@ -423,6 +473,9 @@ private:
                                std::chrono::system_clock::now().time_since_epoch()).count()};
 
     // Member variables - connection state
+    std::unique_ptr<OrcaMqttConnection> mqtt_connection;
+    std::string        m_selected_printer_mqtt_url;   // guarded by m_selected_url_mutex
+    mutable std::mutex m_selected_url_mutex;
     bool is_connected{false};
     bool enable_track{false};
     bool multi_machine_enabled{false};
@@ -436,6 +489,7 @@ private:
     AppOnHttpErrorFn on_http_error_fn;
     GetCountryCodeFn get_country_code_fn;
     QueueOnMainFn queue_on_main_fn;
+    OnMessageFn printer_status_callback;
     mutable std::mutex callback_mutex;
 
     // Thread safety

src/slic3r/Utils/OrcaCloudSignalingChannel.cpp

@@ -0,0 +1,320 @@
+#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(std::shared_ptr<ICloudServiceAgent> cloud, std::string dev_id)
+    : m_cloud(std::move(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;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        conn = m_conn;
+    }
+    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();
+}
+
+std::string OrcaCloudSignalingChannel::host_without_scheme(std::string value)
+{
+    const auto scheme = value.find("://");
+    if (scheme != std::string::npos)
+        value.erase(0, scheme + 3);
+    const auto slash = value.find('/');
+    if (slash != std::string::npos)
+        value.erase(slash);
+    return value;
+}
+
+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();
+        const std::string host = host_without_scheme(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;
+        std::string token_error;
+        unsigned int http_code = 0;
+        auto request = 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([&token_body, &token_error, &http_code](std::string body, std::string error, unsigned status) {
+                http_code = status;
+                token_body = std::move(body);
+                token_error = std::move(error);
+            })
+            .perform_sync();
+        BOOST_LOG_TRIVIAL(info) << "signaling: live-token HTTP " << http_code
+                                << (token_error.empty() ? "" : " error=" + token_error)
+                                << " body=" << token_body.substr(0, 512);
+        try {
+            token_response = nlohmann::json::parse(token_body);
+        } catch (const std::exception& e) {
+            BOOST_LOG_TRIVIAL(warning) << "signaling: live-token body is not JSON: " << e.what();
+        }
+        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();
+        {
+            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().handshake(boost::asio::ssl::stream_base::client);
+        const std::string ws_target = "/api/v1/printers/" + encode_path_component(m_dev_id) +
+                                      "/camera/live?token=" +
+                                      encode_path_component(token_response["token"].get<std::string>());
+        websocket.handshake(host, ws_target);
+        BOOST_LOG_TRIVIAL(info) << "signaling: websocket handshake ok (" << ice_servers.size()
+                                << " ice servers)";
+
+        if (on_ready)
+            on_ready(std::move(ice_servers));
+        send_json(nlohmann::json{{"type", "camera.mode"}, {"mode", "webrtc"}}.dump());
+        // Async read loop, driven by the connection's own io_context. run()
+        // returns once close() has shut the socket down, giving a bounded,
+        // deadlock-free teardown from any thread.
+        do_read(conn);
+        conn->io_context.run();
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "signaling: run() exception: " << e.what();
+        if (!m_stop.load())
+            unavailable(CameraUnavailableReason::Closed, e.what());
+    }
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_conn.reset();
+    }
+    m_open.store(false);
+}
+
+void OrcaCloudSignalingChannel::do_read(std::shared_ptr<Connection> conn)
+{
+    auto buffer = std::make_shared<boost::beast::flat_buffer>();
+    conn->websocket.async_read(
+        *buffer, [this, conn, buffer](boost::system::error_code ec, std::size_t) {
+            if (ec) {
+                if (!m_stop.load())
+                    unavailable(CameraUnavailableReason::Closed, ec.message());
+                return; // do not re-arm; io_context.run() unwinds
+            }
+            const std::string raw = boost::beast::buffers_to_string(buffer->data());
+            // A malformed or unexpectedly-shaped message must not tear down the
+            // session: parse/dispatch is guarded.
+            try {
+                dispatch_message(nlohmann::json::parse(raw), raw);
+            } catch (const std::exception& e) {
+                BOOST_LOG_TRIVIAL(warning) << "signaling: ignoring malformed message: " << e.what()
+                                           << " raw=" << raw.substr(0, 256);
+            }
+            if (!m_stop.load())
+                do_read(conn);
+        });
+}
+
+// Returns the string at key, or "" if absent or not a string (JSON null included).
+static std::string json_string(const nlohmann::json& object, const char* key)
+{
+    const auto it = object.find(key);
+    return (it != object.end() && it->is_string()) ? it->get<std::string>() : std::string{};
+}
+
+void OrcaCloudSignalingChannel::dispatch_message(const nlohmann::json& message, const std::string& raw)
+{
+    const std::string type = json_string(message, "type");
+    BOOST_LOG_TRIVIAL(info) << "signaling: recv type=" << type << " raw=" << raw.substr(0, 256);
+    if (type == "webrtc.answer") {
+        const std::string sdp = json_string(message, "sdp");
+        if (on_answer && !sdp.empty())
+            on_answer(sdp);
+    } else if (type == "webrtc.ice" && message.contains("candidate")) {
+        // The peer may send "candidate" as a flat string or as a nested
+        // RTCIceCandidateInit object { candidate, sdpMid, sdpMLineIndex }.
+        const nlohmann::json& candidate = message["candidate"];
+        std::string sdp_candidate;
+        std::string mid = json_string(message, "sdpMid");
+        if (candidate.is_string()) {
+            sdp_candidate = candidate.get<std::string>();
+        } else if (candidate.is_object()) {
+            sdp_candidate = json_string(candidate, "candidate");
+            std::string nested_mid = json_string(candidate, "sdpMid");
+            if (!nested_mid.empty())
+                mid = std::move(nested_mid);
+        }
+        if (on_ice && !sdp_candidate.empty())
+            on_ice(sdp_candidate, mid);
+    } else if (type == "webrtc.unavailable") {
+        const std::string reason = json_string(message, "reason");
+        unavailable(reason == "busy" ? CameraUnavailableReason::Busy
+                                     : reason == "disabled" ? CameraUnavailableReason::Disabled
+                                                            : CameraUnavailableReason::Error,
+                    reason.empty() ? "error" : reason);
+    }
+}
+
+void OrcaCloudSignalingChannel::send_json(const std::string& message)
+{
+    std::shared_ptr<Connection> conn;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        conn = m_conn;
+    }
+    if (!conn || m_stop.load())
+        return;
+    // Serialize the write onto the io_context thread (same thread that runs
+    // async_read), so reads and writes never touch the stream concurrently.
+    auto payload = std::make_shared<std::string>(message);
+    boost::asio::post(conn->io_context, [this, conn, payload] {
+        if (m_stop.load())
+            return;
+        boost::system::error_code ec;
+        conn->websocket.write(boost::asio::buffer(*payload), ec);
+        if (ec && !m_stop.load())
+            unavailable(CameraUnavailableReason::Closed, ec.message());
+    });
+}
+
+} // namespace Slic3r

src/slic3r/Utils/OrcaCloudSignalingChannel.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include "ICameraSignalingChannel.hpp"
+#include "ICloudServiceAgent.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(std::shared_ptr<ICloudServiceAgent> 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);
+    static std::string host_without_scheme(std::string value);
+
+    std::shared_ptr<ICloudServiceAgent> m_cloud;
+    std::string m_dev_id;
+    std::atomic<bool> m_stop{false};
+    std::atomic<bool> m_open{false};
+    std::thread m_thread;
+    mutable std::mutex m_mutex;
+    std::shared_ptr<Connection> m_conn;
+};
+
+} // namespace Slic3r

src/slic3r/Utils/OrcaMqttConnection.cpp

@@ -0,0 +1,839 @@
+#include "OrcaMqttConnection.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 <boost/log/trivial.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;
+    // 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)
+    {}
+};
+
+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);
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT start url=" << config.url
+                            << " use_tls=" << config.use_tls
+                            << " bearer_provider=" << (config.bearer_provider ? "set" : "null")
+                            << " username_present=" << (!config.username.empty())
+                            << " password_present=" << (!config.password.empty())
+                            << " client_id=" << config.client_id
+                            << " keepalive_seconds=" << config.keepalive_seconds
+                            << " message_callback=" << (on_message ? "set" : "null")
+                            << " state_callback=" << (on_state ? "set" : "null");
+    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;
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT initial connection timed out after 10 seconds"
+                                   << " url=" << current_config.url
+                                   << " last_connack_rc=" << m_last_connack_rc.load()
+                                   << " connected=" << connected.load()
+                                   << "; worker will retry";
+    }
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT start initial_result=" << initial_result
+                            << " initial_completed=" << initial_completed
+                            << " last_connack_rc=" << m_last_connack_rc.load()
+                            << " worker_running=" << (worker.joinable() && !stopping.load());
+    return initial_result;
+}
+
+void OrcaMqttConnection::stop() {
+    std::lock_guard<std::recursive_mutex> lifecycle_lock(lifecycle_mutex);
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT stop requested"
+                            << " url=" << current_config.url
+                            << " connected=" << connected.load()
+                            << " worker_joinable=" << worker.joinable()
+                            << " last_connack_rc=" << m_last_connack_rc.load();
+    stopping.store(true);
+    state_cv.notify_all();
+    {
+        std::lock_guard<std::mutex> lock(connection_mutex);
+        if (active_connection) {
+            // Generic so it accepts either the TLS or the plaintext websocket.
+            auto shutdown_socket = [](auto& websocket) {
+                auto& socket = boost::beast::get_lowest_layer(websocket).socket();
+                boost::system::error_code socket_error;
+                socket.cancel(socket_error);
+                socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, socket_error);
+                socket.close(socket_error);
+            };
+            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
+
+    // beast permits a concurrent writer while the worker is blocked in
+    // websocket.read(); every write is serialised by write_mutex inside ws_write().
+    try {
+        send_pending_subscriptions(*conn);
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: direct subscription write failed (" << e.what()
+                                   << "); worker will resend the full set on reconnect";
+    }
+}
+
+bool OrcaMqttConnection::subscribe(const std::string& dev_id) {
+    if (dev_id.empty()) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT subscribe rejected empty dev_id";
+        return false;
+    }
+    const std::string topic = report_topic(dev_id);
+    if (topic.size() > 96) { // MQTT topic filter cap enforced by the service
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT subscribe rejected oversized topic=" << topic;
+        return false;
+    }
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        if (subscriptions.count(topic) != 0 && pending_unsubscriptions.count(topic) == 0) {
+            BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT subscribe already queued or active topic=" << topic
+                                    << " acknowledged=" << (acknowledged_subscriptions.count(topic) != 0);
+            return true;
+        }
+        subscriptions.insert(topic);
+        pending_unsubscriptions.erase(topic);
+        pending_subscriptions.insert(topic);
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT subscribe queued topic=" << topic
+                                << " total_subscriptions=" << subscriptions.size()
+                                << " connected=" << connected.load();
+    }
+    state_cv.notify_all();
+    flush_subscription_change(); // emit SUBSCRIBE now on the live socket (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;
+        }
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT unsubscribe queued topic=" << topic
+                                << " total_subscriptions=" << subscriptions.size()
+                                << " connected=" << connected.load();
+    }
+    state_cv.notify_all();
+    flush_subscription_change(); // emit UNSUBSCRIBE now on the live socket (no reconnect)
+    return true;
+}
+
+void OrcaMqttConnection::clear_subscriptions() {
+    std::lock_guard<std::mutex> lock(mutex);
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT clear subscriptions count=" << subscriptions.size();
+    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()) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: attempted to send empty MQTT packet";
+        return;
+    }
+    // Writes come from the worker thread AND, for dynamic (un)subscribes, the
+    // caller thread. Serialise them; the worker's concurrent read is fine (beast
+    // allows one reader + one writer).
+    std::lock_guard<std::mutex> lock(write_mutex);
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending MQTT packet type=0x" << std::hex
+                            << static_cast<unsigned int>(packet[0] >> 4) << std::dec
+                            << " bytes=" << packet.size();
+    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));
+    }
+}
+
+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_close(Connection& conn) {
+    boost::system::error_code close_error;
+    if (conn.wss)
+        conn.wss->close(boost::beast::websocket::close_code::normal, close_error);
+    else if (conn.ws)
+        conn.ws->close(boost::beast::websocket::close_code::normal, close_error);
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT connection closed code=" << close_error.value()
+                            << " message=" << close_error.message();
+}
+
+void OrcaMqttConnection::ws_handshake(Connection& conn, const Config& config, const Endpoint& endpoint) {
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: WebSocket resolve starting host=" << endpoint.host
+                            << " port=" << endpoint.port << " target=" << endpoint.target
+                            << " tls=" << config.use_tls;
+    const auto results = conn.resolver.resolve(endpoint.host, endpoint.port);
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT DNS resolution succeeded host=" << endpoint.host;
+
+    std::string token;
+    if (config.bearer_provider) {
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: requesting bearer token for WebSocket upgrade";
+        token = config.bearer_provider();
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: bearer token callback completed token_present=" << !token.empty();
+    }
+    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);
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT TCP connection established host=" << endpoint.host
+                                << " port=" << endpoint.port;
+        // 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");
+        conn.ssl_context.set_default_verify_paths();
+        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);
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT TLS handshake completed host=" << endpoint.host;
+        websocket.set_option(boost::beast::websocket::stream_base::decorator(decorator));
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending TLS WebSocket upgrade target=" << endpoint.target
+                                << " bearer_header=" << (!token.empty());
+        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);
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT TCP connection established host=" << endpoint.host
+                                << " port=" << endpoint.port << " (plaintext)";
+        websocket.set_option(boost::beast::websocket::stream_base::decorator(decorator));
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending plaintext WebSocket upgrade target=" << endpoint.target
+                                << " bearer_header=" << (!token.empty());
+        websocket.handshake(response, endpoint.host, endpoint.target, handshake_error);
+    }
+
+    if (handshake_error) {
+        // Surface the server's HTTP status so a persistent rejection (stale token,
+        // missing api key, wrong route) is diagnosable from the log rather than an
+        // opaque "handshake declined".
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: WS handshake rejected http="
+                                   << response.result_int() << " (" << response.reason() << "), "
+                                   << handshake_error.message();
+        throw boost::system::system_error(handshake_error, "Orca WebSocket handshake");
+    }
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: WebSocket handshake completed http=" << response.result_int()
+                            << " negotiated_protocol=" << response["Sec-WebSocket-Protocol"];
+    if (response["Sec-WebSocket-Protocol"] != "mqtt") {
+        BOOST_LOG_TRIVIAL(error) << "Orca diagnostic: WebSocket handshake did not negotiate 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()) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT send_request rejected empty dev_id";
+        return false;
+    }
+    if (!connected.load()) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT send_request rejected because connection is not ready"
+                                   << " dev_id=" << dev_id << " last_connack_rc=" << m_last_connack_rc.load();
+        return false;
+    }
+    std::shared_ptr<Connection> conn;
+    {
+        std::lock_guard<std::mutex> lock(connection_mutex);
+        conn = active_connection;
+    }
+    if (!conn) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT send_request rejected because active connection is null"
+                                   << " dev_id=" << dev_id;
+        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);
+            BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT request queued until SUBACK"
+                                    << " dev_id=" << dev_id << " payload_bytes=" << payload.size()
+                                    << " pending_requests=" << pending_requests.size();
+            return true;
+        }
+    }
+    try {
+        // ws_write() serialises the write via write_mutex; do not lock it here.
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT PUBLISH request dev_id=" << dev_id
+                                << " topic=" << request_topic(dev_id)
+                                << " payload_bytes=" << payload.size();
+        ws_write(*conn, make_publish_packet(request_topic(dev_id), payload));
+    } catch (const std::exception& e) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: send_request failed dev_id=" << dev_id
+                                   << " (" << e.what() << ")";
+        return false;
+    }
+    return true;
+}
+
+void OrcaMqttConnection::connect_and_read() {
+    m_connection_stage = "creating connection";
+    auto connection = std::make_shared<Connection>();
+    {
+        std::lock_guard<std::mutex> lock(connection_mutex);
+        active_connection = connection;
+        if (stopping.load())
+            return;
+    }
+
+    m_connection_stage = "parsing endpoint";
+    Endpoint endpoint;
+    if (!parse_endpoint(current_config.url, endpoint)) {
+        BOOST_LOG_TRIVIAL(error) << "Orca diagnostic: invalid MQTT endpoint=" << current_config.url;
+        throw std::runtime_error("invalid Orca Cloud WebSocket endpoint");
+    }
+
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT connecting host=" << endpoint.host
+                            << " port=" << endpoint.port << " target=" << endpoint.target;
+
+    m_connection_stage = "WebSocket handshake";
+    ws_handshake(*connection, current_config, endpoint);
+
+    m_connection_stage = "sending MQTT CONNECT";
+    expires_never(*connection);
+    // 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_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT CONNECT packet sent";
+
+    m_connection_stage = "waiting for MQTT CONNACK";
+    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");
+    const std::string connack = boost::beast::buffers_to_string(buffer.data());
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT CONNACK received bytes=" << connack.size()
+                            << " header=" << (connack.empty() ? -1 : static_cast<int>(static_cast<uint8_t>(connack[0])))
+                            << " return_code=" << (connack.size() > 3 ? static_cast<int>(static_cast<uint8_t>(connack[3])) : -1);
+    // 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) {
+        BOOST_LOG_TRIVIAL(error) << "Orca diagnostic: MQTT CONNECT refused rc=" << rc;
+        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));
+    }
+
+    m_connection_stage = "reading MQTT messages";
+    // 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();
+    }
+    notify_state(true);
+    reconnect_delay_seconds.store(1); // a fresh CONNACK resets the backoff
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT connection is ready; sending current subscriptions";
+    send_current_subscriptions(*connection);
+    std::chrono::steady_clock::time_point next_ping = std::chrono::steady_clock::now() + std::chrono::seconds(30);
+
+    while (!stopping.load()) {
+        send_pending_subscriptions(*connection);
+        // Keepalive is driven every iteration, not only from the read-timeout branch:
+        // a printer pushing faster than the 1s read deadline would otherwise keep the
+        // read hot and the broker would drop us at 1.5 x keepalive.
+        if (std::chrono::steady_clock::now() >= next_ping) {
+            ws_write(*connection, make_ping_packet());
+            BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT PINGREQ sent";
+            next_ping = std::chrono::steady_clock::now() + std::chrono::seconds(30);
+        }
+        buffer.consume(buffer.size());
+        m_connection_stage = "reading MQTT frame";
+        expires_after(*connection, std::chrono::seconds(1));
+        boost::system::error_code error;
+        ws_read(*connection, buffer, error);
+        if (error == boost::beast::error::timeout)
+            continue;
+        if (error) {
+            BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT WebSocket read failed code=" << error.value()
+                                       << " message=" << error.message();
+            throw boost::system::system_error(error, "read Orca MQTT message");
+        }
+        handle_packet(boost::beast::buffers_to_string(buffer.data()));
+    }
+
+    ws_close(*connection);
+    if (!stopping.load())
+        notify_state(false);
+}
+
+void OrcaMqttConnection::send_current_subscriptions(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);
+    }
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending current MQTT subscriptions count=" << topics.size();
+    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;
+        }
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending SUBSCRIBE topic=" << topic << " packet_id=" << packet_id;
+        ws_write(conn, make_subscribe_packet(packet_id, topic, 1));
+    }
+}
+
+void OrcaMqttConnection::send_pending_subscriptions(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;
+        }
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending pending SUBSCRIBE topic=" << topic
+                                << " packet_id=" << packet_id;
+        ws_write(conn, make_subscribe_packet(packet_id, topic, 1));
+    }
+    for (const std::string& topic : unsubscribe_topics) {
+        const uint16_t packet_id = next_packet_id++;
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: sending pending UNSUBSCRIBE topic=" << topic
+                                << " packet_id=" << packet_id;
+        ws_write(conn, make_unsubscribe_packet(packet_id, topic));
+    }
+}
+
+void OrcaMqttConnection::handle_packet(const std::string& packet) {
+    if (packet.size() < 2) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: received undersized MQTT packet bytes=" << packet.size();
+        return;
+    }
+    const uint8_t header = static_cast<uint8_t>(packet[0]);
+    const uint8_t packet_type = header >> 4;
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: received MQTT packet type=" << static_cast<unsigned int>(packet_type)
+                            << " header=0x" << std::hex << static_cast<unsigned int>(header) << std::dec
+                            << " bytes=" << packet.size();
+    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]));
+            }
+            BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: received SUBACK packet_id="
+                                    << packet_id
+                                    << " result_codes=" << result_codes.str();
+
+            // 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()) {
+                BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: SUBACK has no pending topic packet_id=" << packet_id;
+            } else if (result == 0 || result == 1) {
+                BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: report subscription active topic=" << topic
+                                        << " granted_qos=" << static_cast<unsigned int>(result)
+                                        << " releasing_requests=" << requests.size();
+                for (const auto& request : requests) {
+                    if (!send_request(request.first, request.second)) {
+                        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: queued MQTT request could not be sent"
+                                                   << " after SUBACK dev_id=" << request.first;
+                    }
+                }
+            } else {
+                BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: report subscription rejected topic=" << topic
+                                           << " result_code=0x" << std::hex << static_cast<unsigned int>(result) << std::dec
+                                           << " dropped_requests=" << requests.size();
+            }
+        }
+        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) {
+            BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: malformed MQTT PUBLISH remaining length";
+            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) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: malformed MQTT PUBLISH body remaining=" << remaining
+                                   << " packet_bytes=" << packet.size();
+        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) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: malformed MQTT PUBLISH topic length=" << topic_length;
+        return;
+    }
+    const std::string topic(packet.data() + index, topic_length);
+    index += topic_length;
+    if (((header >> 1) & 0x03) != 0) {
+        if (index + 2 > remaining_end) {
+            BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: malformed MQTT PUBLISH packet identifier";
+            return;
+        }
+        index += 2; // QoS 1/2 packet identifier; the service currently sends QoS 0.
+    }
+    const size_t payload_size = remaining_end - index;
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: received PUBLISH topic=" << topic
+                            << " payload_bytes=" << payload_size
+                            << " message_callback=" << (on_message ? "set" : "null");
+    // 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()) {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: dropping PUBLISH on unrecognized topic=" << topic;
+    } else if (on_message) {
+        on_message(dev_id, packet.substr(index, remaining_end - index));
+    } else {
+        BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: dropping PUBLISH because message callback is not set";
+    }
+}
+
+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;
+    }
+    BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT state changed connected=" << is_now_connected
+                            << " initial=" << initial << " state_callback=" << (callback ? "set" : "null");
+    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;
+        m_connection_stage = "starting attempt";
+        try {
+            BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT connection attempt=" << attempt
+                                    << " retry_delay=" << retry_seconds
+                                    << " url=" << current_config.url;
+            connect_and_read();
+        } catch (const std::exception& error) {
+            BOOST_LOG_TRIVIAL(warning) << "Orca diagnostic: MQTT connection attempt=" << attempt
+                                       << " failed stage=" << m_connection_stage
+                                       << " error=" << error.what()
+                                       << " last_connack_rc=" << m_last_connack_rc.load()
+                                       << " stopping=" << stopping.load();
+            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);
+        BOOST_LOG_TRIVIAL(info) << "Orca diagnostic: MQTT waiting before reconnect seconds=" << retry_seconds;
+        state_cv.wait_for(lock, std::chrono::seconds(retry_seconds), [this] { return stopping.load(); });
+    }
+}
+
+} // namespace Slic3r

src/slic3r/Utils/OrcaMqttConnection.hpp

@@ -0,0 +1,152 @@
+#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;
+        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).
+    void        ws_write(Connection& conn, const std::vector<uint8_t>& packet); // locks write_mutex
+    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        ws_close(Connection& conn);
+    // Emit a queued SUBSCRIBE/UNSUBSCRIBE on the live socket right now (from the
+    // caller thread), so a selection change is applied without waiting for the
+    // blocking read loop to next return. No-op if no CONNACKed socket exists yet
+    // (the worker sends the set on connect). The WebSocket is never dropped for a
+    // subscription change.
+    void flush_subscription_change();
+    void connect_and_read();
+    void send_current_subscriptions(Connection& conn);
+    void send_pending_subscriptions(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::mutex write_mutex; // serialises every websocket write (worker + caller threads)
+    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
+    std::string m_connection_stage;     // worker-thread diagnostic stage
+    bool initial_result{false};
+    bool initial_completed{false};
+    std::atomic_bool connected{false};
+};
+
+} // namespace Slic3r
+
+#endif // slic3r_OrcaMqttConnection_hpp_

src/slic3r/Utils/OrcaPrinterAgent.hpp

@@ -3,19 +3,28 @@
 
 #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 - Stub implementation for printer operations.
+ * OrcaPrinterAgent - OrcaSonar MQTT printer agent.
  *
- * All printer-related operations are currently stubs that return success.
- * Actual printer connectivity requires the BBL SDK or future Orca implementation.
+ * LAN and cloud commands use the same OrcaSonar protocol payloads; only the
+ * MQTT connection selected by route_send() differs.
  */
-class OrcaPrinterAgent : public IPrinterAgent {
+class OrcaPrinterAgent : public IPrinterAgent
+{
 public:
     explicit OrcaPrinterAgent(std::string log_dir);
     ~OrcaPrinterAgent() override;
@@ -25,6 +34,9 @@ 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;
+    std::unique_ptr<ICameraSignalingChannel> create_camera_signaling_channel(const std::string& dev_id) override;
 
     // Communication
     int send_message(std::string dev_id, std::string json_str, int qos, int flag) override;
@@ -32,20 +44,11 @@ public:
     int disconnect_printer() override;
     int send_message_to_printer(std::string dev_id, std::string json_str, int qos, int flag) override;
 
-    // Certificates
-    int check_cert() override;
-    void install_device_cert(std::string dev_id, bool lan_only) override;
-
     // Discovery
     bool start_discovery(bool start, bool sending) override;
 
     // Binding
-    int ping_bind(std::string ping_code) override;
     int bind_detect(std::string dev_ip, std::string sec_link, detectResult& detect) override;
-    int bind(std::string dev_ip, std::string dev_id, std::string dev_model, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn) override;
-    int unbind(std::string dev_id) override;
-    int request_bind_ticket(std::string* ticket) override;
-    int get_hms_snapshot(std::string dev_id, std::string file_name, std::function<void(std::string, int)> callback) override;
     int set_server_callback(OnServerErrFn fn) override;
 
     // Machine Selection
@@ -77,10 +80,187 @@ 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, std::string 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;
+
+    // Filament sync (subscription): `subscription` when the selected printer
+    // reports a material system (get_capabilities protocol.features.fms),
+    // `none` otherwise. The mode is transport-agnostic; the lane_data fetch and
+    // topology_state doorbell that keep DevFilaSystem fresh are LAN-only, and
+    // cloud printers get their AMS view from the mirrored push_status.
+    FilamentSyncMode get_filament_sync_mode() const override;
+    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) 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; }
+
+    // Test-only: observe the subscription doorbell policy without spawning the refresh worker.
+    bool filament_doorbell_needed_for_test(const std::string& dev_id, const std::string& payload)
+    {
+        return filament_doorbell_needed(dev_id, payload);
+    }
+    // Test-only: arm the fetch-failure latch (retry-on-next-LAN-frame rule).
+    void set_filament_failed_for_test(bool v)
+    {
+        std::lock_guard<std::mutex> lock(state_mutex);
+        m_filament_failed = v;
+    }
+    // Test-only: Bambu ams_* wire JSON -> canonical OrcaSonar bodies (§7.8).
+    // Returns the (possibly rewritten) payload; *unsupported is set when the
+    // device's declared ams_ops exclude the operation (CAP_NOT_AVAILABLE in
+    // the live route_send path).
+    static std::string canonicalize_ams_payload(const std::string& dev_id, const std::string& json_str, bool* unsupported);
+
+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
+    std::string m_lan_http_origin;                                  // guarded by state_mutex — http(s) origin of the LAN façade
+    std::string m_lan_password;                                     // guarded by state_mutex — MQTT access code; X-Api-Key fallback
+    std::string m_lan_api_key;                                      // guarded by state_mutex — cached Moonraker-façade key, "" = unresolved
+    uint64_t m_lan_api_key_gen = 0;                                 // m_lan_generation the cached key belongs to
+    CameraStreamMode m_camera_stream_mode = CameraStreamMode::none; // guarded by state_mutex
+    std::string m_camera_url;                                       // guarded by state_mutex
+
+    // The Moonraker-façade X-Api-Key, bootstrapped from /access/api_key (trusted
+    // clients only) and cached per connection generation; falls back to the
+    // access code when the endpoint is unavailable (untrusted/hardened config).
+    std::string lan_api_key(const std::string& origin);
+
+    // Subscription-mode filament sync. One detached worker per burst drains
+    // m_filament_wanted by re-reading lane_data; doorbell frames (a pushed
+    // print.topology_state change) and the failure latch are the only triggers —
+    // no timer: an idle OrcaSonar emits no frames, and cannot change lanes either.
+    void request_filament_refresh(const std::string& dev_id);
+        // OPCP §7.7: the doorbell is a CHANGE in print.topology_state.material_hash
+    // (lane content only — tool temperature churn inside topology_state must not
+    // re-fetch); consuming a new value updates m_material_hash.
+    bool filament_doorbell_needed(const std::string& dev_id, const std::string& payload);
+
+    // Tri-state lane_data fetch outcome (REQ-STS-007 §7.7 read semantics):
+    //  synced  — 200 with lane entries, payload built;
+    //  none    — 200 with an empty value: authoritative "no lanes", AMS view cleared;
+    //  unknown — 404: topology not bootstrapped yet or material_units unknown;
+    //            never latched, the next doorbell or reconnect retries;
+    //  error   — transport/5xx: latched, retried on the next inbound frame.
+    enum class LaneDataState { synced, none, unknown, error };
+    LaneDataState fetch_lane_data(const std::string& dev_id);
+
+    bool m_filament_wanted  = false; // guarded by state_mutex; a fetch is pending
+    bool m_filament_working = false; // guarded by state_mutex; a worker owns the queue
+    bool m_filament_failed  = false; // guarded by state_mutex; retry-on-next-LAN-frame rule
+    bool m_shutting_down    = false; // guarded by state_mutex; workers stop taking fetches
+    std::string m_material_hash;     // guarded by state_mutex; last doorbell value seen
+    std::atomic<int> m_filament_in_flight{0}; // detached workers; drained by the destructor
+
+    OrcaCloudServiceAgent* get_orca_cloud_agent();
+
+    OrcaMqttConnection* get_appropriate_mqtt_connection(bool is_lan = true);
+    static bool parse_nonnegative_command_id(const std::string& value, int& result);
+
+    // Route one command payload to device/<dev_id>/request on the LAN or the shared
+    // cloud connection. The uniform send path for both send_message* overrides.
+    int route_send(bool is_lan, const std::string& dev_id, const std::string& json_str);
 
     // Callbacks
     OnMsgArrivedFn on_ssdp_msg_fn;

src/slic3r/Utils/PaintCLI.cpp

@@ -1,204 +0,0 @@
-// PaintCLI.cpp — CLI paint-inspection primitives. See PaintCLI.hpp.
-#include "PaintCLI.hpp"
-
-#include "libslic3r/Model.hpp"
-#include "libslic3r/TriangleMesh.hpp"
-#include "libslic3r/TriangleSelector.hpp"
-
-#include <nlohmann/json.hpp>
-
-#include <cmath>
-#include <string>
-#include <utility>
-#include <vector>
-
-namespace Slic3r {
-namespace PaintCLI {
-
-namespace {
-
-using json = nlohmann::json;
-
-double its_surface_area(const indexed_triangle_set &its)
-{
-    double total = 0.0;
-    for (const stl_triangle_vertex_indices &t : its.indices) {
-        const Vec3f &a = its.vertices[t(0)];
-        const Vec3f &b = its.vertices[t(1)];
-        const Vec3f &c = its.vertices[t(2)];
-        total += 0.5 * (b - a).cross(c - a).norm();
-    }
-    return total;
-}
-
-// Bbox over triangle-referenced vertices only. get_facets_strict() returns
-// an itset with the full source vertex list — using bounding_box() on it
-// would report the whole mesh's bbox even when only a few facets are painted.
-BoundingBoxf3 its_referenced_bbox(const indexed_triangle_set &its)
-{
-    BoundingBoxf3 bb;
-    bool first = true;
-    for (const stl_triangle_vertex_indices &t : its.indices) {
-        for (int k = 0; k < 3; ++k) {
-            const Vec3d v = its.vertices[t(k)].cast<double>();
-            if (first) { bb.min = bb.max = v; first = false; }
-            else       bb.merge(v);
-        }
-    }
-    return bb;
-}
-
-json vec3_to_json(const Vec3d &v)
-{
-    return json::array({ v.x(), v.y(), v.z() });
-}
-
-json bbox_to_json(const BoundingBoxf3 &bb)
-{
-    return {
-        { "min",  vec3_to_json(bb.min) },
-        { "max",  vec3_to_json(bb.max) },
-        { "size", vec3_to_json(Vec3d(bb.max - bb.min)) },
-    };
-}
-
-// One (layer, state) row — empty ones are omitted at the caller level.
-json state_entry(const std::string &label, const indexed_triangle_set &its)
-{
-    return {
-        { "state",    label },
-        { "facets",   its.indices.size() },
-        { "area_mm2", its_surface_area(its) },
-        { "bbox",     bbox_to_json(its_referenced_bbox(its)) },
-    };
-}
-
-// Iterate the states relevant to one FacetsAnnotation kind, collecting
-// non-empty entries. Empty layer → {"empty": true}. `n_facets_out` is the
-// running total of painted facets — bumped for the summary.
-json inspect_layer(const ModelVolume &mv, const FacetsAnnotation &fa,
-                   const std::vector<std::pair<EnforcerBlockerType, std::string>> &states,
-                   size_t &n_facets_out)
-{
-    if (fa.empty())
-        return { { "empty", true } };
-
-    json entries = json::array();
-    for (const auto &st : states) {
-        if (!fa.has_facets(mv, st.first))
-            continue;
-        indexed_triangle_set its = fa.get_facets_strict(mv, st.first);
-        if (its.indices.empty())
-            continue;
-        n_facets_out += its.indices.size();
-        entries.push_back(state_entry(st.second, its));
-    }
-    return {
-        { "empty",  entries.empty() },
-        { "states", std::move(entries) },
-    };
-}
-
-const std::vector<std::pair<EnforcerBlockerType, std::string>> &supports_states()
-{
-    static const std::vector<std::pair<EnforcerBlockerType, std::string>> s = {
-        { EnforcerBlockerType::ENFORCER, "ENFORCER" },
-        { EnforcerBlockerType::BLOCKER,  "BLOCKER"  },
-    };
-    return s;
-}
-
-const std::vector<std::pair<EnforcerBlockerType, std::string>> &fuzzy_states()
-{
-    // FUZZY_SKIN is an enum alias for ENFORCER; the layer is single-state.
-    static const std::vector<std::pair<EnforcerBlockerType, std::string>> s = {
-        { EnforcerBlockerType::FUZZY_SKIN, "FUZZY_SKIN" },
-    };
-    return s;
-}
-
-const std::vector<std::pair<EnforcerBlockerType, std::string>> &mmu_states()
-{
-    static std::vector<std::pair<EnforcerBlockerType, std::string>> s = []{
-        std::vector<std::pair<EnforcerBlockerType, std::string>> v;
-        for (int i = 1; i <= int(EnforcerBlockerType::ExtruderMax); ++i)
-            v.emplace_back(EnforcerBlockerType(i), "extruder_" + std::to_string(i));
-        return v;
-    }();
-    return s;
-}
-
-} // namespace
-
-void inspect_to_json(const Model &model, const std::vector<std::string> &source_paths,
-                     std::ostream &out)
-{
-    json root;
-    root["sources"] = source_paths;
-    root["frame"]  = "mesh_local";
-    root["note"]   = "Coordinates are mesh-local (each volume's own frame). "
-                     "Paint gizmos operate in this frame.";
-
-    json objects = json::array();
-    size_t total_objects = 0, total_volumes = 0, total_painted = 0, total_facets = 0;
-
-    for (size_t oi = 0; oi < model.objects.size(); ++oi) {
-        const ModelObject *mo = model.objects[oi];
-        if (!mo) continue;
-        ++total_objects;
-
-        json obj;
-        obj["index"] = oi;
-        obj["name"]  = mo->name;
-
-        json volumes = json::array();
-        for (size_t vi = 0; vi < mo->volumes.size(); ++vi) {
-            const ModelVolume *mv = mo->volumes[vi];
-            if (!mv) continue;
-            ++total_volumes;
-
-            const indexed_triangle_set &its = mv->mesh().its;
-            json vol;
-            vol["index"]    = vi;
-            vol["name"]     = mv->name;
-            vol["n_facets"] = its.indices.size();
-            vol["is_model_part"] = mv->is_model_part();
-            vol["bbox_mesh_local"] = bbox_to_json(bounding_box(its));
-
-            size_t vol_painted = 0;
-            json paints;
-            paints["supports"]         = inspect_layer(*mv, mv->supported_facets,
-                                                      supports_states(),  vol_painted);
-            paints["seam"]             = inspect_layer(*mv, mv->seam_facets,
-                                                      supports_states(),  vol_painted);
-            paints["mmu_segmentation"] = inspect_layer(*mv, mv->mmu_segmentation_facets,
-                                                      mmu_states(),       vol_painted);
-            paints["fuzzy_skin"]       = inspect_layer(*mv, mv->fuzzy_skin_facets,
-                                                      fuzzy_states(),     vol_painted);
-            vol["paints"] = std::move(paints);
-            vol["painted_facets_total"] = vol_painted;
-
-            if (vol_painted > 0) ++total_painted;
-            total_facets += vol_painted;
-
-            volumes.push_back(std::move(vol));
-        }
-        obj["volumes"] = std::move(volumes);
-        objects.push_back(std::move(obj));
-    }
-    root["objects"] = std::move(objects);
-    root["summary"] = {
-        { "objects",                    total_objects },
-        { "volumes",                    total_volumes },
-        { "volumes_with_paint",         total_painted },
-        { "painted_facets_total",       total_facets  },
-    };
-
-    // Object names and file paths are arbitrary bytes, and dump() throws on invalid
-    // UTF-8 by default. Replace such sequences with U+FFFD so the output is always
-    // valid JSON rather than an exception out of the CLI.
-    out << root.dump(2, ' ', false, json::error_handler_t::replace) << std::endl;
-}
-
-} // namespace PaintCLI
-} // namespace Slic3r

src/slic3r/Utils/PaintCLI.hpp

@@ -1,31 +0,0 @@
-// PaintCLI.hpp — CLI paint-inspection primitives.
-//
-// Backs the --inspect-paint CLI action. Reads the per-facet enforcer /
-// blocker / extruder / fuzzy-skin state that OrcaSlicer stores on every
-// ModelVolume (supports, seam, MMU color, fuzzy-skin) and emits a
-// structured JSON summary — facet count, surface area, and mesh-local
-// bounding box per state — so CI / scripted / AI tooling can reason
-// about existing paint on a .3mf without opening the GUI.
-//
-// Coordinates are mesh-local (each volume's own frame), matching the
-// frame that the paint gizmos operate in.
-#ifndef slic3r_PaintCLI_hpp_
-#define slic3r_PaintCLI_hpp_
-
-#include <iosfwd>
-#include <string>
-#include <vector>
-
-namespace Slic3r {
-class Model;
-
-namespace PaintCLI {
-
-// `source_paths` lists every input file; the CLI merges them into one Model.
-void inspect_to_json(const Model &model, const std::vector<std::string> &source_paths,
-                     std::ostream &out);
-
-} // namespace PaintCLI
-} // namespace Slic3r
-
-#endif

src/slic3r/Utils/PrinterNetworkTypes.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <string>
+
+namespace Slic3r {
+
+enum LiveviewLocal {
+    LVL_None,
+    LVL_Disable,
+    LVL_Local,
+    LVL_Rtsps,
+    LVL_Rtsp
+};
+
+enum LiveviewRemote {
+    LVR_None,
+    LVR_Tutk,
+    LVR_Agora,
+    LVR_TutkAgora
+};
+
+enum FileLocal {
+    FL_None,
+    FL_Local
+};
+
+enum FileRemote {
+    FR_None,
+    FR_Tutk,
+    FR_Agora,
+    FR_TutkAgora
+};
+
+} // namespace Slic3r

src/slic3r/Utils/QidiPrinterAgent.cpp

@@ -1,5 +1,6 @@
 #include "QidiPrinterAgent.hpp"
 #include "Http.hpp"
+#include "IPrinterAgent.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
@@ -8,6 +9,7 @@
 #include <boost/log/trivial.hpp>
 #include <cctype>
 #include <sstream>
+#include <thread>
 
 using json = nlohmann::json;
 
@@ -27,6 +29,15 @@ 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";
@@ -40,42 +51,141 @@ AgentInfo QidiPrinterAgent::get_agent_info_static()
     return AgentInfo{"qidi", "Qidi", QidiPrinterAgent_VERSION, "Qidi printer agent"};
 }
 
-bool QidiPrinterAgent::fetch_filament_info(std::string dev_id)
+FilamentSyncMode QidiPrinterAgent::get_filament_sync_mode() const
 {
-    std::string error;
+    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
+        return FilamentSyncMode::subscription;
+    return FilamentSyncMode::pull;
+}
 
-    // 1. Fetch device info and infer series_id
-    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);
+bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
+{
+    if (sync_mode != get_filament_sync_mode())
+        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.
+    std::string base_url   = device_info.base_url;
+    std::string api_key    = device_info.api_key;
+    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, base_url, api_key, model_id, model_name]() {
+        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(base_url, 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(model_id, model_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;
-    }
+        // 2. Fetch filament dictionary
+        QidiFilamentDict dict;
+        if (!fetch_filament_dict(base_url, 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;
+        // 3. Fetch slot info and build AmsTrayData directly
+        std::vector<AmsTrayData> trays;
+        int box_count = 0;
+        if (!fetch_slot_info(base_url, api_key, 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();
+    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;
     }
 
-    // 4. Build the AMS payload
-    build_ams_payload(box_count, box_count * 4 - 1, trays);
+    // 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 std::string&        base_url,
                                        const std::string&        api_key,
                                        const QidiFilamentDict&   dict,
@@ -120,20 +230,10 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
         return false;
     }
 
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-    if (json.is_discarded()) {
-        error = "Invalid JSON response";
+    nlohmann::json status;
+    nlohmann::json variables;
+    if (!parse_slot_response(response_body, status, variables, error))
         return false;
-    }
-
-    if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("save_variables") ||
-        !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) {
@@ -208,6 +308,31 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
     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 std::string& base_url,
                                            const std::string& api_key,
                                            QidiFilamentDict& dict,

src/slic3r/Utils/QidiPrinterAgent.hpp

@@ -1,7 +1,9 @@
 #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>
@@ -19,9 +21,25 @@ public:
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
     // Override filament sync (Qidi-specific implementation)
-    bool fetch_filament_info(std::string dev_id) override;
+    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;

src/slic3r/Utils/SnapmakerPrinterAgent.cpp

@@ -1,10 +1,14 @@
 #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;
 
@@ -13,6 +17,13 @@ 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>
@@ -69,6 +80,31 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
 
 SnapmakerPrinterAgent::SnapmakerPrinterAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
 
+void SnapmakerPrinterAgent::start_camera_monitor()
+{
+    std::thread([this] {
+        send_ws_rpc("camera.start_monitor",
+                    {{"domain", "lan"}, {"interval", 0}, {"expect_pw", false}});
+    }).detach();
+    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"};
@@ -104,127 +140,164 @@ std::string SnapmakerPrinterAgent::combine_filament_type(const std::string& type
     return base;
 }
 
-bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id)
+bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
 {
-    std::string url = join_url(device_info.base_url, "/printer/objects/query?print_task_config&filament_detect");
-
-    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;
+    (void) dev_id;
+    if (sync_mode != get_filament_sync_mode())
         return false;
-    }
 
-    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;
-    }
+    const std::string base_url = device_info.base_url;
+    const std::string api_key  = device_info.api_key;
 
-    // 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;
-    }
+    filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
 
-    auto& ptc = json["result"]["status"]["print_task_config"];
+    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};
 
-    // 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 std::string url = join_url(base_url, "/printer/objects/query?print_task_config&filament_detect");
 
-    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;
-    }
+        std::string response_body;
+        bool success = false;
+        std::string http_error;
 
-    // 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;
+        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;
                 } else {
-                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
+                    http_error = "HTTP error: " + std::to_string(status);
                 }
-            } else {
-                tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
-            }
+            })
+            .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();
 
-            // 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);
-                }
-            }
+        if (!success) {
+            BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
+            return;
         }
 
-        trays.emplace_back(std::move(tray));
-    }
+        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);
+
+                // 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);
+                    }
+                }
+            }
+
+            trays.emplace_back(std::move(tray));
+        }
+
+        // Preset matching (vendor + closest color) reads GUI preset state, so it
+        // runs on the main thread via this resolver, not on the fetch worker.
+        std::vector<std::string> vendors;
+        vendors.reserve(slot_count);
+        for (int i = 0; i < slot_count; ++i)
+            vendors.push_back(safe_at(filament_vendor, i, empty_str));
+
+        build_ams_payload(1, slot_count - 1, trays,
+            [vendors](std::vector<AmsTrayData>& resolved) { resolve_snapmaker_tray_info(resolved, vendors); });
+    }).detach();
 
-    build_ams_payload(1, slot_count - 1, trays);
     return true;
 }
 
+void SnapmakerPrinterAgent::resolve_snapmaker_tray_info(std::vector<AmsTrayData>& trays,
+                                                        const std::vector<std::string>& vendors)
+{
+    auto* bundle = GUI::wxGetApp().preset_bundle;
+    for (auto& tray : trays) {
+        if (!tray.has_filament)
+            continue;
+        const std::string vendor = (tray.slot_index >= 0 && tray.slot_index < static_cast<int>(vendors.size()))
+                                       ? vendors[tray.slot_index]
+                                       : std::string();
+        if (bundle) {
+            // Try a matching preset by vendor, type and color; fall back to
+            // type only, then to the generic family map.
+            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 " << tray.slot_index << ": " << 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);
+        }
+    }
+}
+
+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