Merge branch 'main' into feat/printer-agent-impl

Port the U1 top cover purifier mode and the related start G-code
changes from Snapmaker's Orca (Snapmaker/OrcaSlicer#504 and
Snapmaker/OrcaSlicer#1005, as of 8931178229).

The start G-code sends SET_PURIFIER_MODE for strong cooling, weak
cooling or keep warm, picked from the lowest softening temperature of
the filaments used through min_vitrification_temperature, with
Snapmaker's thresholds and parameters. It also pre-extrudes the first
tool, and turns the part fan off for probing and back on for nozzle
cleaning.

U1 filament presets use Snapmaker's softening temperatures. U1 presets
that have no U1 version in Snapmaker's Orca use the value Snapmaker
gives that material on the U1.

.claude/skills/orca-wxwidgets/references/platforms.md

@@ -574,7 +574,8 @@ DMABUF workaround and then branches on `GDK_BACKEND` (an `x11` prefix means the
 paths, when `/proc/driver/nvidia/version` exists and the linked WebKitGTK honours the switch (>= 2.44,
 `WebView::SupportsForceSharedMemory()`), it sets `WEBKIT_DMABUF_RENDERER_FORCE_SHM=1` and
 `WEBKIT_FORCE_DMABUF_RENDERER=1` (non-replacing): the proprietary driver cannot back WebKit's hardware
-DMABUF renderer. On the default path it forces `GDK_BACKEND=x11` when wx lacks EGL and `WAYLAND_DISPLAY`
+DMABUF renderer. On a hypervisor guest (`/proc/cpuinfo` `hypervisor` flag) and WebKitGTK >= 2.44 it sets
+`WEBKIT_DMABUF_RENDERER_FORCE_SHM=1` alone, since virtual GPUs cannot back the hardware path either. On the default path it forces `GDK_BACKEND=x11` when wx lacks EGL and `WAYLAND_DISPLAY`
 is set, and sets `WEBKIT_DISABLE_COMPOSITING_MODE=1` (non-replacing) inside that branch when the linked
 WebKitGTK is older than 2.42: a forced X11 backend in a Wayland session is the only default-path case
 that runs through XWayland, which `DISPLAY` and `WAYLAND_DISPLAY` alone do not tell you (a native

.claude/skills/orca-wxwidgets/references/webview-gl-aui-media.md

@@ -568,13 +568,18 @@ vue-resize workaround script and sets a persistent SQLite cookie store on the vi
 ## WebKitGTK on Linux sessions
 
 **Mechanism.** `CLI::run` (`src/OrcaSlicer.cpp`, under `#ifdef __WXGTK__`, before GTK initialises)
-sets the NVIDIA DMABUF workaround and then branches on `GDK_BACKEND`:
+sets the DMABUF workarounds and then branches on `GDK_BACKEND`:
 - **Both paths**, before the split: when `/proc/driver/nvidia/version` exists and the linked WebKitGTK
   honours the switch (>= 2.44, `WebView::SupportsForceSharedMemory()`), it sets
   `WEBKIT_DMABUF_RENDERER_FORCE_SHM=1` and `WEBKIT_FORCE_DMABUF_RENDERER=1` non-replacing. The
   proprietary driver cannot back WebKit's hardware DMABUF renderer, so the shared-memory transport keeps
   accelerated compositing instead of dropping it; `WEBKIT_FORCE_DMABUF_RENDERER` clears the
   Debian/Ubuntu/openSUSE `isNVIDIA()` early return, which otherwise returns before the FORCE_SHM check.
+- **Hypervisor guests**, same position: when `is_hypervisor_guest()` (the `hypervisor` flag in
+  `/proc/cpuinfo`) and WebKitGTK >= 2.44, it sets `WEBKIT_DMABUF_RENDERER_FORCE_SHM=1` non-replacing.
+  Virtual GPUs (VirtualBox VMSVGA, VMware, QEMU) cannot back the hardware DMABUF path either, and
+  FORCE_SHM alone was confirmed to fix web views in VirtualBox; the `WEBKIT_FORCE_DMABUF_RENDERER` pair
+  is not needed without the Debian `isNVIDIA()` patch. The flag is x86-only, so ARM guests are not covered.
 - **Default path** (`GDK_BACKEND` unset or not starting with `x11`): if wx lacks EGL (`!wxHAS_EGL`) and
   `WAYLAND_DISPLAY` is set, it forces `GDK_BACKEND=x11`, and in that same branch it sets
   `WEBKIT_DISABLE_COMPOSITING_MODE=1` non-replacing when the linked WebKitGTK predates 2.42
@@ -590,9 +595,9 @@ Runtime backend detection elsewhere uses Orca's `is_running_on_wayland()` / `is_
 (see `references/platforms.md`), not these environment variables.
 
 **Pitfall.**
-- **Rule:** On NVIDIA reach for `WEBKIT_DMABUF_RENDERER_FORCE_SHM` before
+- **Rule:** On NVIDIA and hypervisor guests reach for `WEBKIT_DMABUF_RENDERER_FORCE_SHM` before
-  `WEBKIT_DISABLE_COMPOSITING_MODE`. **Why:** the proprietary driver cannot back WebKit's hardware
+  `WEBKIT_DISABLE_COMPOSITING_MODE`. **Why:** the proprietary driver and virtual GPUs cannot back WebKit's
-  DMABUF renderer, leaving web views blank or slow; FORCE_SHM keeps accelerated compositing and only
+  hardware DMABUF renderer, leaving web views blank or slow; FORCE_SHM keeps accelerated compositing and only
   skips the hardware path, while disabling compositing drops it. Threaded scrolling is a separate,
   release-dependent default (off in 2.44/2.45, on from 2.46). `WEBKIT_DISABLE_DMABUF_RENDERER` is not a
   substitute — it is read first, leaves the transport set empty (no compositing from 2.44 on, where the

.github/workflows/check_profiles.yml

@@ -232,6 +232,31 @@ jobs:
           mkdir -p ${{ runner.temp }}/profile-check-results
           echo "${{ github.event.pull_request.number }}" > ${{ runner.temp }}/profile-check-results/pr_number.txt
 
+      # Builds a readable diff of the custom G-code the PR changes, which GitHub shows as
+      # one long line per setting, for check_profiles_comment.yml to post.
+      - name: Diff custom G-code
+        if: ${{ always() && github.event_name == 'pull_request' }}
+        continue-on-error: true
+        env:
+          PR_HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: |
+          git fetch --no-tags --depth=2 origin "$(git rev-parse HEAD)"
+          results=${{ runner.temp }}/profile-check-results
+          diff=${{ runner.temp }}/gcode_diff.md
+          # HEAD is the PR's merge commit, so HEAD^1 is the base it merges onto.
+          python3 ./scripts/orca_profile_tool.py gcode-diff --base HEAD^1 --head HEAD > "$diff"
+          if [ -s "$diff" ]; then
+            {
+              echo "<!-- profile-gcode-diff-comment -->"
+              cat "$diff"
+              echo ""
+              # The comment workflow finds this line as the only one starting with <sub>.
+              echo "<sub>For commit ${PR_HEAD_SHA} of this PR.</sub>"
+            } > "$results/gcode_diff.md"
+          fi
+          # Tells the comment workflow that a missing gcode_diff.md means no G-code changed.
+          touch "$results/gcode_diff_done.txt"
+
       - name: Prepare comment artifact
         if: ${{ always() && github.event_name == 'pull_request' && (steps.profile_tool.outcome == 'failure' || steps.legacy_compat.outcome == 'failure' || steps.validate_system.outcome == 'failure' || steps.validate_slice.outcome == 'failure' || steps.validate_filament_subtypes.outcome == 'failure' || steps.validate_custom.outcome == 'failure') }}
         run: |

.github/workflows/check_profiles_comment.yml

@@ -38,6 +38,7 @@ jobs:
         env:
           GH_TOKEN: ${{ github.token }}
           GH_REPO: ${{ github.repository }}
+          HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
         run: |
           if [ ! -f pr_number.txt ]; then
             echo "No pr_number.txt in artifact, skipping."
@@ -49,18 +50,72 @@ jobs:
             echo "Invalid PR number: $PR_NUMBER"
             exit 1
           fi
+          # PR code wrote the artifact, so only a run for the named PR's current head may post.
+          if [ -z "$HEAD_SHA" ]; then
+            echo "The triggering run names no head commit."
+            exit 1
+          fi
+          if ! PR_HEAD=$(gh api "repos/${GH_REPO}/pulls/${PR_NUMBER}" --jq .head.sha); then
+            echo "Cannot look up PR #${PR_NUMBER}."
+            exit 1
+          fi
+          if [ "$HEAD_SHA" != "$PR_HEAD" ]; then
+            echo "${HEAD_SHA} is not the head of PR #${PR_NUMBER}; skipping."
+            exit 0
+          fi
+
+          # Lists every bot comment on the PR, one JSON object per line.
+          COMMENTS=$(gh api --paginate "repos/${GH_REPO}/issues/${PR_NUMBER}/comments" \
+            --jq '.[] | select(.user.login == "github-actions[bot]") | {id, body} | @json')
 
           # Delete prior comments matching the marker (from check_profiles.yml) or the legacy heading.
-          OLD_IDS=$(gh api --paginate "repos/${GH_REPO}/issues/${PR_NUMBER}/comments" \
+          OLD_IDS=$(printf '%s\n' "$COMMENTS" | jq -r 'select((.body | startswith("<!-- profile-validation-comment -->")) or (.body | startswith("## :x: Profile Validation Errors"))) | .id')
-            --jq '.[] | select(.user.login == "github-actions[bot]") | select((.body | startswith("<!-- profile-validation-comment -->")) or (.body | startswith("## :x: Profile Validation Errors"))) | .id')
           for comment_id in $OLD_IDS; do
             echo "Deleting outdated profile-validation comment ${comment_id}"
             gh api -X DELETE "repos/${GH_REPO}/issues/comments/${comment_id}" || true
           done
 
           # Post a new comment only when validation failed (pr_comment.md present).
+          # A failed post fails the job only after the G-code diff is handled.
+          failed=0
           if [ -f pr_comment.md ]; then
-            gh pr comment "$PR_NUMBER" --body-file pr_comment.md
+            gh pr comment "$PR_NUMBER" --body-file pr_comment.md || failed=1
           else
             echo "Validation succeeded; cleaned up prior comments without posting."
           fi
+
+          # Makes the G-code diff comment match gcode_diff.md, or deletes it if there is none.
+          update_gcode_diff_comment() {
+            if [ ! -f gcode_diff_done.txt ]; then
+              echo "The G-code diff step did not finish; leaving any G-code diff comment as it is."
+              return 0
+            fi
+            GCODE_IDS=$(printf '%s\n' "$COMMENTS" | jq -r 'select(.body | startswith("<!-- profile-gcode-diff-comment -->")) | .id')
+            if [ -f gcode_diff.md ] && [ "$(wc -c < gcode_diff.md)" -gt 65536 ]; then
+              echo "gcode_diff.md is over GitHub's comment limit; not posting it."
+              rm gcode_diff.md
+            fi
+            if [ -f gcode_diff.md ] && [ "$(echo "$GCODE_IDS" | wc -w)" -eq 1 ]; then
+              OLD_BODY=$(printf '%s\n' "$COMMENTS" | jq -r --argjson id "$GCODE_IDS" 'select(.id == $id) | .body' | tr -d '\r')
+              NEW_BODY=$(tr -d '\r' < gcode_diff.md)
+              if [ "$OLD_BODY" = "$NEW_BODY" ]; then
+                echo "G-code diff unchanged; keeping comment ${GCODE_IDS}."
+                return 0
+              fi
+              # Edits in place when only the <sub> line differs, since edits notify nobody.
+              if [ "$(grep -v '^<sub>' <<< "$OLD_BODY")" = "$(grep -v '^<sub>' <<< "$NEW_BODY")" ]; then
+                echo "G-code diff unchanged at a new commit; updating comment ${GCODE_IDS}."
+                gh api -X PATCH "repos/${GH_REPO}/issues/comments/${GCODE_IDS}" -F body=@gcode_diff.md > /dev/null
+                return 0
+              fi
+            fi
+            for comment_id in $GCODE_IDS; do
+              echo "Deleting outdated G-code diff comment ${comment_id}"
+              gh api -X DELETE "repos/${GH_REPO}/issues/comments/${comment_id}" || true
+            done
+            if [ -f gcode_diff.md ]; then
+              gh pr comment "$PR_NUMBER" --body-file gcode_diff.md
+            fi
+          }
+          update_gcode_diff_comment
+          exit "$failed"

CMakeLists.txt

@@ -288,6 +288,19 @@ if (APPLE)
     # Type"); Ninja/-Wall does not, and under -Werror it fails Xcode builds on code CI accepts.
     set(CMAKE_XCODE_ATTRIBUTE_GCC_WARN_64_TO_32_BIT_CONVERSION "NO")
 
+    # The Xcode generator ignores CMAKE_<LANG>_COMPILER_LAUNCHER, so hand the launcher to
+    # Xcode's own Compiler Launcher setting, which wraps every clang compile (C, C++,
+    # Objective-C++ and the precompiled header) with one program: the C++ launcher wins when
+    # both are set. The setting takes a single program path, not a CMake launcher list.
+    # Xcode versions without it ignore it and build uncached.
+    if (CMAKE_GENERATOR STREQUAL "Xcode")
+        if (CMAKE_CXX_COMPILER_LAUNCHER)
+            set(CMAKE_XCODE_ATTRIBUTE_C_COMPILER_LAUNCHER "${CMAKE_CXX_COMPILER_LAUNCHER}")
+        elseif (CMAKE_C_COMPILER_LAUNCHER)
+            set(CMAKE_XCODE_ATTRIBUTE_C_COMPILER_LAUNCHER "${CMAKE_C_COMPILER_LAUNCHER}")
+        endif ()
+    endif ()
+
     message(STATUS "Orca: IS_CROSS_COMPILE: ${IS_CROSS_COMPILE}")
 elseif (CMAKE_SYSTEM_NAME STREQUAL "Linux")
     set(CMAKE_INSTALL_RPATH "$ORIGIN")

build_release_macos.sh

@@ -111,6 +111,54 @@ else
   export CMAKE_POLICY_COMPAT=""
 fi
 
+# Compiler cache, as in build_linux.sh. The program comes from CMAKE_CCACHE, else from a
+# launcher already set in the environment (the CI build sets ccache there), else sccache or
+# ccache from PATH; one program serves both languages. Each run applies its own choice to the
+# build directories, replacing a launcher an earlier run or a hand-run configure recorded.
+CMAKE_CCACHE_ARGS=()
+CCACHE_VAR=""
+for var in CMAKE_CCACHE CMAKE_CXX_COMPILER_LAUNCHER CMAKE_C_COMPILER_LAUNCHER; do
+    if [ -n "${!var:-}" ]; then
+        CCACHE_VAR=$var
+        break
+    fi
+done
+if [ -n "$CCACHE_VAR" ]; then
+    CCACHE_PROGRAM=${!CCACHE_VAR}
+    echo "Checking ${CCACHE_VAR} environment variable for compiler cache program..."
+    CMAKE_CCACHE=$(command -v "${CCACHE_PROGRAM}") || {
+        echo "${CCACHE_VAR} environment variable is set to '${CCACHE_PROGRAM}' but it was not found in PATH."
+        CMAKE_CCACHE=""
+    }
+elif command -v sccache >/dev/null 2>&1 ; then
+    CMAKE_CCACHE=$(command -v sccache)
+elif command -v ccache >/dev/null 2>&1 ; then
+    CMAKE_CCACHE=$(command -v ccache)
+fi
+if [ -n "${CMAKE_CCACHE}" ] ; then
+    echo "${CMAKE_CCACHE} found, enabling compiler caching..."
+    CMAKE_CCACHE_ARGS=(-DCMAKE_C_COMPILER_LAUNCHER="${CMAKE_CCACHE}" -DCMAKE_CXX_COMPILER_LAUNCHER="${CMAKE_CCACHE}")
+    # The same ccache settings as the CI build. Without this sloppiness ccache refuses every
+    # compile that uses the precompiled header, which is most of OrcaSlicer, and skips headers
+    # a checkout has just written. It is added to the sloppiness already configured, and
+    # CCACHE_SLOPPINESS or CCACHE_(NO)DEPEND set in the environment win.
+    if [[ "$(basename "${CMAKE_CCACHE}")" == ccache ]] ; then
+        if [[ -z "${CCACHE_SLOPPINESS+x}" ]] ; then
+            CCACHE_SLOPPINESS=$("${CMAKE_CCACHE}" --get-config sloppiness 2>/dev/null || true)
+            export CCACHE_SLOPPINESS="${CCACHE_SLOPPINESS:+${CCACHE_SLOPPINESS},}pch_defines,time_macros,include_file_mtime,include_file_ctime"
+        fi
+        # Hash the includes the compiler reports instead of preprocessing every miss.
+        if [[ -z "${CCACHE_DEPEND+x}${CCACHE_NODEPEND+x}" ]] ; then
+            export CCACHE_DEPEND=1
+        fi
+    fi
+else
+    echo "Note: ccache or sccache are not found. Install either of them for faster rebuilds."
+    # Clear a launcher recorded by an earlier configure. The entries must be set empty rather
+    # than removed: CMake fills a missing launcher entry from the environment.
+    CMAKE_CCACHE_ARGS=(-DCMAKE_C_COMPILER_LAUNCHER:STRING= -DCMAKE_CXX_COMPILER_LAUNCHER:STRING=)
+fi
+
 echo "Build params:"
 echo " - ARCH: $ARCH"
 echo " - BUILD_CONFIG: $BUILD_CONFIG"
@@ -162,6 +210,7 @@ function build_deps() {
                         -DCMAKE_OSX_ARCHITECTURES:STRING="${_ARCH}" \
                         -DCMAKE_OSX_DEPLOYMENT_TARGET="${OSX_DEPLOYMENT_TARGET}" \
                         -DCMAKE_IGNORE_PREFIX_PATH="${CMAKE_IGNORE_PREFIX_PATH}" \
+                        "${CMAKE_CCACHE_ARGS[@]}" \
                         ${CMAKE_POLICY_COMPAT}
                 fi
                 cmake --build . --config "$BUILD_CONFIG" --target deps
@@ -264,6 +313,7 @@ function build_slicer() {
                     -DCMAKE_OSX_ARCHITECTURES="${_ARCH}" \
                     -DCMAKE_OSX_DEPLOYMENT_TARGET="${OSX_DEPLOYMENT_TARGET}" \
                     -DCMAKE_IGNORE_PREFIX_PATH="${CMAKE_IGNORE_PREFIX_PATH}" \
+                    "${CMAKE_CCACHE_ARGS[@]}" \
                     ${CMAKE_POLICY_COMPAT}
             fi
             cmake --build . --config "$BUILD_CONFIG" --target "$SLICER_BUILD_TARGET"

docs/HLSD/keyboard-shortcuts.md

@@ -53,6 +53,13 @@ Space counts as typing. The speed dial's default is the one bare Space, and
 `MainFrame` leaves it to a focused control that uses Space itself (text fields, buttons,
 combo boxes), so it opens the dial from the canvases and the tab strip only.
 
+`MainFrame::handle_global_shortcut` skips a chord that `KeyChord::edits_text()` reports
+while a text field has the focus (a wx text entry, spin control, web view or ImGui
+InputText), and skips every chord while an ImGui modal is open, as a wx modal dialog
+would. `ImGuiWrapper::owns_key()` reads the active InputText and the popup stack
+directly, since `WantCaptureKeyboard` lags a frame, and is called only when the focus is on
+a visible canvas from `OpenGLManager::create_wxglcanvas()`.
+
 ## Which event a chord matches
 
 Letters, digits and special keys match on `wxEVT_KEY_DOWN`. Its key codes do not depend

resources/profiles/Snapmaker.json

@@ -1,6 +1,6 @@
 {
 	"name": "Snapmaker",
-	"version": "02.04.00.17",
+	"version": "02.04.00.18",
 	"force_update": "0",
 	"description": "Snapmaker configurations",
 	"machine_model_list": [

resources/profiles/Snapmaker/filament/Snapmaker ABS @U1 base.json

@@ -49,5 +49,8 @@
 	],
 	"pressure_advance": [
 		"0.02"
+	],
+	"temperature_vitrification": [
+		"100"
 	]
 }

resources/profiles/Snapmaker/filament/Snapmaker ASA @U1 base.json

@@ -46,5 +46,8 @@
 	],
 	"fan_min_speed": [
 		"0"
+	],
+	"temperature_vitrification": [
+		"100"
 	]
 }

resources/profiles/Snapmaker/filament/Snapmaker PETG @U1 base.json

@@ -45,7 +45,7 @@
 		"250"
 	],
 	"temperature_vitrification": [
-		"178"
+		"70"
 	],
 	"fan_max_speed": [
 		"20"

resources/profiles/Snapmaker/filament/Snapmaker PETG Translucent @U1 base.json

@@ -4,5 +4,8 @@
 	"inherits": "fdm_filament_petg",
 	"from": "system",
 	"filament_id": "OFW8lqnb",
-	"instantiation": "false"
+	"instantiation": "false",
+	"temperature_vitrification": [
+		"70"
+	]
 }

resources/profiles/Snapmaker/filament/Snapmaker PETG-CF @U1 base.json

@@ -60,7 +60,7 @@
 		"250"
 	],
 	"temperature_vitrification": [
-		"178"
+		"70"
 	],
 	"fan_max_speed": [
 		"20"

resources/profiles/Snapmaker/filament/Snapmaker PLA @U1 base.json

@@ -34,5 +34,8 @@
 	],
 	"nozzle_temperature": [
 		"220"
+	],
+	"temperature_vitrification": [
+		"45"
 	]
 }

resources/profiles/Snapmaker/filament/Snapmaker PLA Eco @U1 base.json

@@ -34,5 +34,8 @@
 	],
 	"filament_cooling_final_speed": [
 		"60"
+	],
+	"temperature_vitrification": [
+		"45"
 	]
 }

resources/profiles/Snapmaker/filament/Snapmaker PLA Glow @U1 base.json

@@ -34,5 +34,8 @@
 	],
 	"nozzle_temperature": [
 		"220"
+	],
+	"temperature_vitrification": [
+		"45"
 	]
 }

resources/profiles/Snapmaker/filament/Snapmaker PLA Metal @U1 base.json

@@ -40,5 +40,8 @@
 	],
 	"nozzle_temperature": [
 		"220"
+	],
+	"temperature_vitrification": [
+		"45"
 	]
 }

resources/profiles/Snapmaker/filament/Snapmaker PVA @U1 base.json

@@ -31,5 +31,8 @@
 	],
 	"slow_down_layer_time": [
 		"8"
+	],
+	"temperature_vitrification": [
+		"45"
 	]
 }

resources/profiles/Snapmaker/filament/Snapmaker TPE @U1.json

@@ -50,5 +50,8 @@
 	"additional_cooling_fan_speed": [
 		"70",
 		"70"
+	],
+	"temperature_vitrification": [
+		"30"
 	]
 }

resources/profiles/Snapmaker/filament/Snapmaker TPU 95A @U1 base.json

@@ -137,7 +137,7 @@
 		"240"
 	],
 	"temperature_vitrification": [
-		"60"
+		"30"
 	],
 	"nozzle_temperature_range_low": [
 		"200"

resources/profiles/Snapmaker/filament/Snapmaker TPU 95A @U1.json

@@ -302,7 +302,7 @@
 		"-1"
 	],
 	"temperature_vitrification": [
-		"60"
+		"30"
 	],
 	"textured_cool_plate_temp": [
 		"40"

resources/profiles/Snapmaker/filament/Snapmaker TPU @U1.json

@@ -29,5 +29,8 @@
 	"additional_cooling_fan_speed": [
 		"70",
 		"70"
+	],
+	"temperature_vitrification": [
+		"30"
 	]
 }

resources/profiles/Snapmaker/filament/Snapmaker TPU High-Flow @U1.json

@@ -49,5 +49,8 @@
 	"additional_cooling_fan_speed": [
 		"70",
 		"70"
+	],
+	"temperature_vitrification": [
+		"30"
 	]
 }

resources/profiles/Snapmaker/machine/Snapmaker U1 (0.2 nozzle).json

@@ -97,7 +97,7 @@
 		"20",
 		"12"
 	],
-	"machine_start_gcode": "SET_PRINT_AUTO_BED_LEVELING ENABLE=1\nSET_TIME_LAPSE_CAMERA ENABLE=1\n;===== date: 20260128 =====================\n\nPRINT_START\nDEFECT_DETECTION_START\nSET_PRINT_STATS_INFO TOTAL_LAYER={total_layer_count} CURRENT_LAYER=0\nTIMELAPSE_START\nM140 S{bed_temperature_initial_layer_single}\nM104 T{initial_extruder} S140\nM204 S10000\nG28 X Y\nDEFECT_DETECT_NOODLE_FIRST\n;===== 床面异物检测 ========\nT{initial_extruder}\nG90\nDEFECT_DETECTION_DETECT_BED\n;===== 取放头检测 =================\nSM_PRINT_CHECK_SWITCH_EXTRUDER\n\n;===== 自动进料 & 挤出流量 & 预挤出 ======================\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=1 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=0\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=0\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=2 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=1\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=1\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=3 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=2\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=2\nSM_PRINT_AUTO_FEED EXTRUDER=3\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=3\nM104 S0 T0 A0\nM104 S0 T1 A0\nM104 S0 T2 A0\nM104 S0 T3 A0\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\n\n;===== 粗回零 =================\nT{initial_extruder}\nM106 S255\nM106 P2 S0\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\nROUGHLY_CLEAN_NOZZLE_WITH_DISCARD\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nG28 Z I140 J140\n\n;===== 检测钢板 =================\nDETECT_BED_PLATE\n\n;===== 深度清洁喷嘴 =================\nG90\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 S{nozzle_temperature[initial_extruder] - 50}\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_1\nM104 S{nozzle_temperature[initial_extruder] - 90}\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_2\n\n;===== 精回零 =================\nM106 S255\nM109 S{nozzle_temperature[initial_extruder] - 90}\nM190 S{bed_temperature_initial_layer_single}\nM107 P2\nG90\nG0 Z5 F10000\nWAIT_CHAMBER_TEMP TIMEOUT=180\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \nG28 Z Z_OFFSET -0.07                                                                                                                                                                                                                                    \n{else}                                                                                                                                                                                                               \nG28 Z                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n{endif} \n\n\n;===== 热床调平 =================\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0 Z_OFFSET=-0.07\n{else}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0\n{endif} \n\n\n;===== 画起始线 =================\nG90\nG1 Z1.5\nG0 X85 Y1 Z2 F18000\nM109 S{nozzle_temperature_initial_layer[initial_extruder]}\nG1 Z0.2\nM83\nG1 X185 E15 F360\nG1 Z1.5\n\nG90\nM106 S0",
+	"machine_start_gcode": "SET_PRINT_AUTO_BED_LEVELING ENABLE=1\nSET_TIME_LAPSE_CAMERA ENABLE=1\n;===== date: 20260128 =====================\n\nPRINT_START\nDEFECT_DETECTION_START\nSET_PRINT_STATS_INFO TOTAL_LAYER={total_layer_count} CURRENT_LAYER=0\nTIMELAPSE_START\nM140 S{bed_temperature_initial_layer_single}\nM104 T{initial_extruder} S140\nM204 S10000\n;===== top cover purifier =====\n{if min_vitrification_temperature <= 50}\nSET_PURIFIER_MODE MODE=1 DESIRE_TEMP=42 ALARM_TEMP=48 FAN_SPEED=0.6 DELAY_OFF=0 ; strong cooling\n{elsif min_vitrification_temperature <= 70}\nSET_PURIFIER_MODE MODE=1 DESIRE_TEMP=45 ALARM_TEMP=51 FAN_SPEED=0.6 DELAY_OFF=0 ; weak cooling\n{else}\nSET_PURIFIER_MODE MODE=3 DESIRE_TEMP=45 FAN_SPEED=0.6 DELAY_OFF=600 ; keep warm\n{endif}\nG28 X Y\nDEFECT_DETECT_NOODLE_FIRST\n;===== 床面异物检测 ========\nT{initial_extruder}\nG90\nDEFECT_DETECTION_DETECT_BED\n;===== 取放头检测 =================\nSM_PRINT_CHECK_SWITCH_EXTRUDER\n\n;===== 自动进料 & 挤出流量 & 预挤出 ======================\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=1 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=0\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=0\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=2 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=1\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=1\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=3 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=2\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=2\nSM_PRINT_AUTO_FEED EXTRUDER=3\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=3\nM104 S0 T0 A0\nM104 S0 T1 A0\nM104 S0 T2 A0\nM104 S0 T3 A0\n\n;==== 预挤出耗材 =====\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder]}\nT{initial_extruder}\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder]}\nSM_PRINT_PREEXTRUDE_FILAMENT INDEX={initial_extruder}\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\n\n;===== 粗回零 =================\nT{initial_extruder}\nM106 S255\nM106 P2 S0\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\nROUGHLY_CLEAN_NOZZLE_WITH_DISCARD\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nM107\nG28 Z I140 J140\n\n;===== 检测钢板 =================\nM107\nDETECT_BED_PLATE\n\n;===== 深度清洁喷嘴 =================\nM106 S255\nG90\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 S{nozzle_temperature[initial_extruder] - 50}\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_1\nM104 S{nozzle_temperature[initial_extruder] - 90}\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_2\n\n;===== 精回零 =================\nM106 S255\nM109 S{nozzle_temperature[initial_extruder] - 90}\nM190 S{bed_temperature_initial_layer_single}\nM107 P2\nG90\nG0 Z5 F10000\nWAIT_CHAMBER_TEMP TIMEOUT=180\nM107\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \nG28 Z Z_OFFSET -0.07                                                                                                                                                                                                                                    \n{else}                                                                                                                                                                                                               \nG28 Z                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n{endif} \n\n\n;===== 热床调平 =================\nM107\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0 Z_OFFSET=-0.07\n{else}                                                                                                                                                                                                               \n; AlwLine truncated
 	"machine_tool_change_time": "5",
 	"max_layer_height": [
 		"0.14",

resources/profiles/Snapmaker/machine/Snapmaker U1 (0.4 nozzle).json

@@ -97,7 +97,7 @@
 		"20",
 		"12"
 	],
-	"machine_start_gcode": "SET_PRINT_AUTO_BED_LEVELING ENABLE=1\nSET_TIME_LAPSE_CAMERA ENABLE=1\n;===== date: 20260128 =====================\n\nPRINT_START\nDEFECT_DETECTION_START\nSET_PRINT_STATS_INFO TOTAL_LAYER={total_layer_count} CURRENT_LAYER=0\nTIMELAPSE_START\nM140 S{bed_temperature_initial_layer_single}\nM104 T{initial_extruder} S140\nM204 S10000\nG28 X Y\nDEFECT_DETECT_NOODLE_FIRST\n;===== 床面异物检测 ========\nT{initial_extruder}\nG90\nDEFECT_DETECTION_DETECT_BED\n;===== 取放头检测 =================\nSM_PRINT_CHECK_SWITCH_EXTRUDER\n\n;===== 自动进料 & 挤出流量 & 预挤出 ======================\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=1 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=0\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=0\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=2 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=1\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=1\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=3 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=2\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=2\nSM_PRINT_AUTO_FEED EXTRUDER=3\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=3\nM104 S0 T0 A0\nM104 S0 T1 A0\nM104 S0 T2 A0\nM104 S0 T3 A0\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\n\n;===== 粗回零 =================\nT{initial_extruder}\nM106 S255\nM106 P2 S0\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\nROUGHLY_CLEAN_NOZZLE_WITH_DISCARD\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nG28 Z I140 J140\n\n;===== 检测钢板 =================\nDETECT_BED_PLATE\n\n;===== 深度清洁喷嘴 =================\nG90\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 S{nozzle_temperature[initial_extruder] - 50}\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_1\nM104 S{nozzle_temperature[initial_extruder] - 90}\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_2\n\n;===== 精回零 =================\nM106 S255\nM109 S{nozzle_temperature[initial_extruder] - 90}\nM190 S{bed_temperature_initial_layer_single}\nM107 P2\nG90\nG0 Z5 F10000\nWAIT_CHAMBER_TEMP TIMEOUT=180\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \nG28 Z Z_OFFSET -0.07                                                                                                                                                                                                                                    \n{else}                                                                                                                                                                                                               \nG28 Z                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n{endif} \n\n\n;===== 热床调平 =================\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0 Z_OFFSET=-0.07\n{else}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0\n{endif} \n\n\n;===== 画起始线 =================\nG90\nG1 Z1.5\nG0 X85 Y1 Z2 F18000\nM109 S{nozzle_temperature_initial_layer[initial_extruder]}\nG1 Z0.2\nM83\nG1 X185 E15 F360\nG1 Z1.5\n\nG90\nM106 S0",
+	"machine_start_gcode": "SET_PRINT_AUTO_BED_LEVELING ENABLE=1\nSET_TIME_LAPSE_CAMERA ENABLE=1\n;===== date: 20260128 =====================\n\nPRINT_START\nDEFECT_DETECTION_START\nSET_PRINT_STATS_INFO TOTAL_LAYER={total_layer_count} CURRENT_LAYER=0\nTIMELAPSE_START\nM140 S{bed_temperature_initial_layer_single}\nM104 T{initial_extruder} S140\nM204 S10000\n;===== top cover purifier =====\n{if min_vitrification_temperature <= 50}\nSET_PURIFIER_MODE MODE=1 DESIRE_TEMP=42 ALARM_TEMP=48 FAN_SPEED=0.6 DELAY_OFF=0 ; strong cooling\n{elsif min_vitrification_temperature <= 70}\nSET_PURIFIER_MODE MODE=1 DESIRE_TEMP=45 ALARM_TEMP=51 FAN_SPEED=0.6 DELAY_OFF=0 ; weak cooling\n{else}\nSET_PURIFIER_MODE MODE=3 DESIRE_TEMP=45 FAN_SPEED=0.6 DELAY_OFF=600 ; keep warm\n{endif}\nG28 X Y\nDEFECT_DETECT_NOODLE_FIRST\n;===== 床面异物检测 ========\nT{initial_extruder}\nG90\nDEFECT_DETECTION_DETECT_BED\n;===== 取放头检测 =================\nSM_PRINT_CHECK_SWITCH_EXTRUDER\n\n;===== 自动进料 & 挤出流量 & 预挤出 ======================\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=1 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=0\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=0\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=2 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=1\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=1\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=3 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=2\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=2\nSM_PRINT_AUTO_FEED EXTRUDER=3\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=3\nM104 S0 T0 A0\nM104 S0 T1 A0\nM104 S0 T2 A0\nM104 S0 T3 A0\n\n;==== 预挤出耗材 =====\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder]}\nT{initial_extruder}\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder]}\nSM_PRINT_PREEXTRUDE_FILAMENT INDEX={initial_extruder}\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\n\n;===== 粗回零 =================\nT{initial_extruder}\nM106 S255\nM106 P2 S0\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\nROUGHLY_CLEAN_NOZZLE_WITH_DISCARD\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nM107\nG28 Z I140 J140\n\n;===== 检测钢板 =================\nM107\nDETECT_BED_PLATE\n\n;===== 深度清洁喷嘴 =================\nM106 S255\nG90\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 S{nozzle_temperature[initial_extruder] - 50}\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_1\nM104 S{nozzle_temperature[initial_extruder] - 90}\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_2\n\n;===== 精回零 =================\nM106 S255\nM109 S{nozzle_temperature[initial_extruder] - 90}\nM190 S{bed_temperature_initial_layer_single}\nM107 P2\nG90\nG0 Z5 F10000\nWAIT_CHAMBER_TEMP TIMEOUT=180\nM107\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \nG28 Z Z_OFFSET -0.07                                                                                                                                                                                                                                    \n{else}                                                                                                                                                                                                               \nG28 Z                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n{endif} \n\n\n;===== 热床调平 =================\nM107\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0 Z_OFFSET=-0.07\n{else}                                                                                                                                                                                                               \n; AlwLine truncated
 	"machine_tool_change_time": "5",
 	"max_layer_height": [
 		"0.32",

resources/profiles/Snapmaker/machine/Snapmaker U1 (0.6 nozzle).json

@@ -97,7 +97,7 @@
 		"20",
 		"12"
 	],
-	"machine_start_gcode": "SET_PRINT_AUTO_BED_LEVELING ENABLE=1\nSET_TIME_LAPSE_CAMERA ENABLE=1\n;===== date: 20260128 =====================\n\nPRINT_START\nDEFECT_DETECTION_START\nSET_PRINT_STATS_INFO TOTAL_LAYER={total_layer_count} CURRENT_LAYER=0\nTIMELAPSE_START\nM140 S{bed_temperature_initial_layer_single}\nM104 T{initial_extruder} S140\nM204 S10000\nG28 X Y\nDEFECT_DETECT_NOODLE_FIRST\n;===== 床面异物检测 ========\nT{initial_extruder}\nG90\nDEFECT_DETECTION_DETECT_BED\n;===== 取放头检测 =================\nSM_PRINT_CHECK_SWITCH_EXTRUDER\n\n;===== 自动进料 & 挤出流量 & 预挤出 ======================\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=1 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=0\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=0\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=2 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=1\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=1\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=3 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=2\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=2\nSM_PRINT_AUTO_FEED EXTRUDER=3\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=3\nM104 S0 T0 A0\nM104 S0 T1 A0\nM104 S0 T2 A0\nM104 S0 T3 A0\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\n\n;===== 粗回零 =================\nT{initial_extruder}\nM106 S255\nM106 P2 S0\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\nROUGHLY_CLEAN_NOZZLE_WITH_DISCARD\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nG28 Z I140 J140\n\n;===== 检测钢板 =================\nDETECT_BED_PLATE\n\n;===== 深度清洁喷嘴 =================\nG90\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 S{nozzle_temperature[initial_extruder] - 50}\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_1\nM104 S{nozzle_temperature[initial_extruder] - 90}\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_2\n\n;===== 精回零 =================\nM106 S255\nM109 S{nozzle_temperature[initial_extruder] - 90}\nM190 S{bed_temperature_initial_layer_single}\nM107 P2\nG90\nG0 Z5 F10000\nWAIT_CHAMBER_TEMP TIMEOUT=180\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \nG28 Z Z_OFFSET -0.07                                                                                                                                                                                                                                    \n{else}                                                                                                                                                                                                               \nG28 Z                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n{endif} \n\n\n;===== 热床调平 =================\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0 Z_OFFSET=-0.07\n{else}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0\n{endif} \n\n\n;===== 画起始线 =================\nG90\nG1 Z1.5\nG0 X85 Y1 Z2 F18000\nM109 S{nozzle_temperature_initial_layer[initial_extruder]}\nG1 Z0.2\nM83\nG1 X185 E15 F360\nG1 Z1.5\n\nG90\nM106 S0",
+	"machine_start_gcode": "SET_PRINT_AUTO_BED_LEVELING ENABLE=1\nSET_TIME_LAPSE_CAMERA ENABLE=1\n;===== date: 20260128 =====================\n\nPRINT_START\nDEFECT_DETECTION_START\nSET_PRINT_STATS_INFO TOTAL_LAYER={total_layer_count} CURRENT_LAYER=0\nTIMELAPSE_START\nM140 S{bed_temperature_initial_layer_single}\nM104 T{initial_extruder} S140\nM204 S10000\n;===== top cover purifier =====\n{if min_vitrification_temperature <= 50}\nSET_PURIFIER_MODE MODE=1 DESIRE_TEMP=42 ALARM_TEMP=48 FAN_SPEED=0.6 DELAY_OFF=0 ; strong cooling\n{elsif min_vitrification_temperature <= 70}\nSET_PURIFIER_MODE MODE=1 DESIRE_TEMP=45 ALARM_TEMP=51 FAN_SPEED=0.6 DELAY_OFF=0 ; weak cooling\n{else}\nSET_PURIFIER_MODE MODE=3 DESIRE_TEMP=45 FAN_SPEED=0.6 DELAY_OFF=600 ; keep warm\n{endif}\nG28 X Y\nDEFECT_DETECT_NOODLE_FIRST\n;===== 床面异物检测 ========\nT{initial_extruder}\nG90\nDEFECT_DETECTION_DETECT_BED\n;===== 取放头检测 =================\nSM_PRINT_CHECK_SWITCH_EXTRUDER\n\n;===== 自动进料 & 挤出流量 & 预挤出 ======================\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=1 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=0\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=0\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=2 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=1\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=1\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=3 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=2\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=2\nSM_PRINT_AUTO_FEED EXTRUDER=3\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=3\nM104 S0 T0 A0\nM104 S0 T1 A0\nM104 S0 T2 A0\nM104 S0 T3 A0\n\n;==== 预挤出耗材 =====\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder]}\nT{initial_extruder}\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder]}\nSM_PRINT_PREEXTRUDE_FILAMENT INDEX={initial_extruder}\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\n\n;===== 粗回零 =================\nT{initial_extruder}\nM106 S255\nM106 P2 S0\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\nROUGHLY_CLEAN_NOZZLE_WITH_DISCARD\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nM107\nG28 Z I140 J140\n\n;===== 检测钢板 =================\nM107\nDETECT_BED_PLATE\n\n;===== 深度清洁喷嘴 =================\nM106 S255\nG90\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 S{nozzle_temperature[initial_extruder] - 50}\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_1\nM104 S{nozzle_temperature[initial_extruder] - 90}\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_2\n\n;===== 精回零 =================\nM106 S255\nM109 S{nozzle_temperature[initial_extruder] - 90}\nM190 S{bed_temperature_initial_layer_single}\nM107 P2\nG90\nG0 Z5 F10000\nWAIT_CHAMBER_TEMP TIMEOUT=180\nM107\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \nG28 Z Z_OFFSET -0.07                                                                                                                                                                                                                                    \n{else}                                                                                                                                                                                                               \nG28 Z                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n{endif} \n\n\n;===== 热床调平 =================\nM107\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0 Z_OFFSET=-0.07\n{else}                                                                                                                                                                                                               \n; AlwLine truncated
 	"machine_tool_change_time": "5",
 	"max_layer_height": [
 		"0.42",

resources/profiles/Snapmaker/machine/Snapmaker U1 (0.8 nozzle).json

@@ -97,7 +97,7 @@
 		"20",
 		"12"
 	],
-	"machine_start_gcode": "SET_PRINT_AUTO_BED_LEVELING ENABLE=1\nSET_TIME_LAPSE_CAMERA ENABLE=1\n;===== date: 20260128 =====================\n\nPRINT_START\nDEFECT_DETECTION_START\nSET_PRINT_STATS_INFO TOTAL_LAYER={total_layer_count} CURRENT_LAYER=0\nTIMELAPSE_START\nM140 S{bed_temperature_initial_layer_single}\nM104 T{initial_extruder} S140\nM204 S10000\nG28 X Y\nDEFECT_DETECT_NOODLE_FIRST\n;===== 床面异物检测 ========\nT{initial_extruder}\nG90\nDEFECT_DETECTION_DETECT_BED\n;===== 取放头检测 =================\nSM_PRINT_CHECK_SWITCH_EXTRUDER\n\n;===== 自动进料 & 挤出流量 & 预挤出 ======================\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=1 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=0\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=0\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=2 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=1\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=1\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=3 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=2\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=2\nSM_PRINT_AUTO_FEED EXTRUDER=3\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=3\nM104 S0 T0 A0\nM104 S0 T1 A0\nM104 S0 T2 A0\nM104 S0 T3 A0\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\n\n;===== 粗回零 =================\nT{initial_extruder}\nM106 S255\nM106 P2 S0\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\nROUGHLY_CLEAN_NOZZLE_WITH_DISCARD\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nG28 Z I140 J140\n\n;===== 检测钢板 =================\nDETECT_BED_PLATE\n\n;===== 深度清洁喷嘴 =================\nG90\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 S{nozzle_temperature[initial_extruder] - 50}\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_1\nM104 S{nozzle_temperature[initial_extruder] - 90}\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_2\n\n;===== 精回零 =================\nM106 S255\nM109 S{nozzle_temperature[initial_extruder] - 90}\nM190 S{bed_temperature_initial_layer_single}\nM107 P2\nG90\nG0 Z5 F10000\nWAIT_CHAMBER_TEMP TIMEOUT=180\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \nG28 Z Z_OFFSET -0.07                                                                                                                                                                                                                                    \n{else}                                                                                                                                                                                                               \nG28 Z                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n{endif} \n\n\n;===== 热床调平 =================\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0 Z_OFFSET=-0.07\n{else}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0\n{endif} \n\n\n;===== 画起始线 =================\nG90\nG1 Z1.5\nG0 X85 Y1 Z2 F18000\nM109 S{nozzle_temperature_initial_layer[initial_extruder]}\nG1 Z0.2\nM83\nG1 X185 E15 F360\nG1 Z1.5\n\nG90\nM106 S0",
+	"machine_start_gcode": "SET_PRINT_AUTO_BED_LEVELING ENABLE=1\nSET_TIME_LAPSE_CAMERA ENABLE=1\n;===== date: 20260128 =====================\n\nPRINT_START\nDEFECT_DETECTION_START\nSET_PRINT_STATS_INFO TOTAL_LAYER={total_layer_count} CURRENT_LAYER=0\nTIMELAPSE_START\nM140 S{bed_temperature_initial_layer_single}\nM104 T{initial_extruder} S140\nM204 S10000\n;===== top cover purifier =====\n{if min_vitrification_temperature <= 50}\nSET_PURIFIER_MODE MODE=1 DESIRE_TEMP=42 ALARM_TEMP=48 FAN_SPEED=0.6 DELAY_OFF=0 ; strong cooling\n{elsif min_vitrification_temperature <= 70}\nSET_PURIFIER_MODE MODE=1 DESIRE_TEMP=45 ALARM_TEMP=51 FAN_SPEED=0.6 DELAY_OFF=0 ; weak cooling\n{else}\nSET_PURIFIER_MODE MODE=3 DESIRE_TEMP=45 FAN_SPEED=0.6 DELAY_OFF=600 ; keep warm\n{endif}\nG28 X Y\nDEFECT_DETECT_NOODLE_FIRST\n;===== 床面异物检测 ========\nT{initial_extruder}\nG90\nDEFECT_DETECTION_DETECT_BED\n;===== 取放头检测 =================\nSM_PRINT_CHECK_SWITCH_EXTRUDER\n\n;===== 自动进料 & 挤出流量 & 预挤出 ======================\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=1 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=0\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=0\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=2 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=1\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=1\nSM_PRINT_EXTRUDER_PREHEAT EXTRUDER=3 TEMP=140\nSM_PRINT_AUTO_FEED EXTRUDER=2\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=2\nSM_PRINT_AUTO_FEED EXTRUDER=3\nSM_PRINT_FLOW_CALIBRATE EXTRUDER=3\nM104 S0 T0 A0\nM104 S0 T1 A0\nM104 S0 T2 A0\nM104 S0 T3 A0\n\n;==== 预挤出耗材 =====\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder]}\nT{initial_extruder}\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder]}\nSM_PRINT_PREEXTRUDE_FILAMENT INDEX={initial_extruder}\nM104 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\n\n;===== 粗回零 =================\nT{initial_extruder}\nM106 S255\nM106 P2 S0\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 T{initial_extruder} S{nozzle_temperature[initial_extruder] - 90}\nROUGHLY_CLEAN_NOZZLE_WITH_DISCARD\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nM107\nG28 Z I140 J140\n\n;===== 检测钢板 =================\nM107\nDETECT_BED_PLATE\n\n;===== 深度清洁喷嘴 =================\nM106 S255\nG90\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nM109 S{nozzle_temperature[initial_extruder] - 50}\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_1\nM104 S{nozzle_temperature[initial_extruder] - 90}\nG0 Z5 F10000\nMOVE_TO_DISCARD_FILAMENT_POSITION\nROUGHLY_CLEAN_NOZZLE\nMOVE_TO_XY_IDLE_POSITION_EXTRUDER\nFINELY_CLEAN_NOZZLE_STAGE_2\n\n;===== 精回零 =================\nM106 S255\nM109 S{nozzle_temperature[initial_extruder] - 90}\nM190 S{bed_temperature_initial_layer_single}\nM107 P2\nG90\nG0 Z5 F10000\nWAIT_CHAMBER_TEMP TIMEOUT=180\nM107\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \nG28 Z Z_OFFSET -0.07                                                                                                                                                                                                                                    \n{else}                                                                                                                                                                                                               \nG28 Z                                                                                                                                                                                                                                                                                                                                                                                                                                                                          \n{endif} \n\n\n;===== 热床调平 =================\nM107\n{if curr_bed_type==\"High Temp Plate\"}                                                                                                                                                                                                               \n; Always pass `ADAPTIVE_MARGIN=0` because Orca has already handled `adaptive_bed_mesh_margin` internally\n; Make sure to set ADAPTIVE to 0 otherwise Klipper will use it's own adaptive bed mesh logic\nBED_MESH_CALIBRATE mesh_min={adaptive_bed_mesh_min[0]},{adaptive_bed_mesh_min[1]} mesh_max={adaptive_bed_mesh_max[0]},{adaptive_bed_mesh_max[1]} ALGORITHM=[bed_mesh_algo] PROBE_COUNT={bed_mesh_probe_count[0]},{bed_mesh_probe_count[1]} ADAPTIVE=0 ADAPTIVE_MARGIN=0 Z_OFFSET=-0.07\n{else}                                                                                                                                                                                                               \n; AlwLine truncated
 	"machine_tool_change_time": "5",
 	"max_layer_height": [
 		"0.56",

scripts/flatpak/com.orcaslicer.OrcaSlicer.metainfo.xml

@@ -45,28 +45,10 @@
         <color type="primary" scheme_preference="dark">#00695C</color>
     </branding>
     <releases>
-        <release version="2.5.0-alpha" date="2026-10-14" type="development">
+        <release version="2.5.0-dev" date="2026-06-22" type="development">
-            <url type="details">https://www.orcaslicer.com/wiki/releases/release_2_5_0_alpha</url>
+            <url type="details">https://github.com/OrcaSlicer/OrcaSlicer/releases/tag/nightly-builds</url>
             <description>
-                <p>See the release page for detailed changelog of OrcaSlicer 2.5.0-alpha release.</p>
+                <p>See the release page for detailed changelog.</p>
-            </description>
-        </release>
-        <release version="2.4.2" date="2026-07-26">
-            <url type="details">https://www.orcaslicer.com/wiki/releases/release_2_4_2</url>
-            <description>
-                <p>See the release page for detailed changelog of OrcaSlicer 2.4.2 release.</p>
-            </description>
-        </release>
-        <release version="2.4.1" date="2026-06-26">
-            <url type="details">https://www.orcaslicer.com/wiki/releases/release_2_4_1</url>
-            <description>
-                <p>See the release page for detailed changelog of OrcaSlicer 2.4.1 release.</p>
-            </description>
-        </release>
-        <release version="2.4.0" date="2026-06-20">
-            <url type="details">https://www.orcaslicer.com/wiki/releases/release_2_4_0</url>
-            <description>
-                <p>See the release page for detailed changelog of OrcaSlicer 2.4.0 release.</p>
             </description>
         </release>
         <release version="2.3.2" date="2025-03-23">

scripts/orca_profile_tool.py

@@ -12,6 +12,7 @@ commands:
   trim             delete profile files no <vendor>.json list references
   update-index     regenerate the *_list sections of <vendor>.json
   legacy-compat    write the printers user presets can be migrated back to
+  gcode-diff       print a readable markdown diff of changed custom G-code
 
 options shared by several commands:
   --vendor VENDOR      act on one vendor bundle only; repeatable, empty means all
@@ -94,11 +95,14 @@ parent in the OFL map. filament_vendor / filament_type resolve the same way.
 """
 
 import argparse
+import difflib
 import functools
+import html
 import json
 import os
 import posixpath
 import re
+import subprocess
 import sys
 import uuid
 from collections import Counter, defaultdict
@@ -192,6 +196,7 @@ VECTOR_KEYS = {
 
 PRINT_CONFIG_CPP = os.path.normpath(
     os.path.join(SCRIPTS_DIR, "..", "src", "libslic3r", "PrintConfig.cpp"))
+TAB_CPP = os.path.normpath(os.path.join(SCRIPTS_DIR, "..", "src", "slic3r", "GUI", "Tab.cpp"))
 
 
 @functools.lru_cache(maxsize=None)
@@ -313,11 +318,11 @@ REMEDY_HINTS = {
 }
 
 
-def print_error(msg):
+def print_error(msg, file=None):
-    print(f"\033[91m[ERROR]\033[0m {msg}")  # Red
+    print(f"\033[91m[ERROR]\033[0m {msg}", file=file)  # Red
 
-def print_warning(msg):
+def print_warning(msg, file=None):
-    print(f"\033[93m[WARNING]\033[0m {msg}")  # Yellow
+    print(f"\033[93m[WARNING]\033[0m {msg}", file=file)  # Yellow
 
 def print_info(msg):
     print(f"\033[94m[INFO]\033[0m {msg}")  # Blue
@@ -3209,6 +3214,223 @@ def run_legacy_compat(base_dir, profiles_dir, output, check):
     return 0
 
 
+# ---------------------------------------------------------------------------
+# gcode-diff
+# ---------------------------------------------------------------------------
+
+# UTF-8 bytes, kept well under GitHub's 65,536-character comment limit.
+GCODE_DIFF_BUDGET = 60000
+# The file names a section's summary shows before "and N more".
+GCODE_DIFF_SUMMARY_FILES = 3
+
+GCODE_DIFF_HEADER = (
+    "## Custom G-code changes\n"
+    "\n"
+    "GitHub shows custom G-code in a profile as one long line, so below is a line by line "
+    "diff of each changed G-code or other text setting.\n")
+
+
+@functools.lru_cache(maxsize=None)
+def _text_option_keys():
+    """The string options PrintConfig.cpp defines as G-code or other multi-line text
+    (every *_gcode option, and every one it marks multiline, such as notes), plus the
+    ones Tab.cpp edits as code, such as filename_format."""
+    with open(PRINT_CONFIG_CPP, encoding="utf-8") as f:
+        source = f.read()
+    keys = set()
+    for body in re.split(r"\bdef\s*=\s*this->add(?:_nullable)?\(", source)[1:]:
+        match = re.match(r'"(\w+)",\s*coStrings?\b', body)
+        if match and (match.group(1).endswith("_gcode")
+                      or re.search(r"def->multiline\s*=\s*true", body)):
+            keys.add(match.group(1))
+    if "machine_start_gcode" not in keys:
+        raise RuntimeError(f"{PRINT_CONFIG_CPP} no longer defines machine_start_gcode")
+    # Tab.cpp only adds keys, so a missing file is not an error.
+    try:
+        with open(TAB_CPP, encoding="utf-8") as f:
+            gui = f.read()
+    except OSError:
+        gui = ""
+    keys.update(re.findall(r'get_option\("(\w+)"\);(?:(?!get_option\().)*?\bis_code\s*=\s*true',
+                           gui, re.DOTALL))
+    return frozenset(keys)
+
+
+def _git(cwd, *args, stdin=None):
+    return subprocess.run(["git", "-C", cwd, *args], input=stdin, check=True,
+                          capture_output=True).stdout
+
+
+def _blobs_at(profiles_dir, specs):
+    """{(ref, path): bytes, or None if not a file there} for (ref, path relative to
+    profiles_dir) pairs, all read by one git cat-file process."""
+    prefix = _git(profiles_dir, "rev-parse", "--show-prefix").decode("utf-8").strip()
+    out = _git(profiles_dir, "cat-file", "--batch",
+               stdin="".join(f"{ref}:{prefix}{rel}\n" for ref, rel in specs).encode("utf-8"))
+    blobs, pos = {}, 0
+    for spec in specs:
+        end = out.index(b"\n", pos)
+        header = out[pos:end]
+        pos = end + 1
+        # "<name> missing" and "<name> ambiguous" have no content; "<oid> <type> <size>" does.
+        if header.endswith((b" missing", b" ambiguous")):
+            blobs[spec] = None
+            continue
+        _oid, kind, size = header.split()
+        blobs[spec] = out[pos:pos + int(size)] if kind == b"blob" else None
+        pos += int(size) + 1
+    return blobs
+
+
+def _parse_profile(raw, rel, where):
+    """The JSON in raw, or None with a warning when it is absent or not JSON."""
+    if raw is None:
+        print_warning(f"{rel}: skipped, not found at {where}", file=sys.stderr)
+        return None
+    try:
+        return json.loads(raw.decode("utf-8-sig"))
+    except ValueError as e:
+        print_warning(f"{rel}: skipped, cannot read it at {where}: {e}", file=sys.stderr)
+        return None
+
+
+def _changed_profiles(profiles_dir, base, head):
+    """(old path, new path) of each JSON file under profiles_dir that differs between
+    base and head (the working tree, untracked files included, when None); the absent
+    side of an added or deleted file is None, and so is a side that is not JSON. Renames
+    are paired."""
+    out = _git(profiles_dir, "diff", "--name-status", "-z", "-M", "--relative", base,
+               *([head] if head else []), "--", ".")
+    fields = out.decode("utf-8").split("\0")
+    pairs, i = [], 0
+    while i + 1 < len(fields):
+        status = fields[i]
+        old = new = fields[i + 1]
+        if status[0] in "RC":
+            new = fields[i + 2]
+            i += 3
+        else:
+            i += 2
+        old = None if status[0] == "A" or not old.endswith(".json") else old
+        new = None if status[0] == "D" or not new.endswith(".json") else new
+        if old or new:
+            pairs.append((old, new))
+    if head is None:
+        out = _git(profiles_dir, "ls-files", "-z", "--others", "--exclude-standard", "--", ".")
+        pairs += [(None, rel) for rel in out.decode("utf-8").split("\0")
+                  if rel.endswith(".json") and rel.split("/")[0] != USER_DIR]
+    return pairs
+
+
+def _text_lines(value):
+    return [line.rstrip() for line in value.split("\n")] if value else []
+
+
+def _text_changes(old, new):
+    """(setting, unified diff) for every G-code or other text value that differs
+    between two profiles; a vector option with several values gives one per value."""
+    changes = []
+    for key in list(new) + [k for k in old if k not in new]:
+        a, b = _as_list(old.get(key, [])), _as_list(new.get(key, []))
+        if a == b or not all(isinstance(v, str) for v in a + b):
+            continue
+        if key not in _text_option_keys() and not any("\n" in v for v in a + b):
+            continue
+        width = max(len(a), len(b))
+        for i in range(width):
+            diff = list(difflib.unified_diff(
+                _text_lines(a[i] if i < len(a) else ""), _text_lines(b[i] if i < len(b) else ""),
+                lineterm=""))[2:]  # drops the ---/+++ file header
+            if diff:
+                changes.append((key if width == 1 else f"{key}[{i}]", "\n".join(diff)))
+    return changes
+
+
+def _gcode_diff_section(files, setting, diff):
+    # A fence longer than any backtick run in the G-code cannot be closed by it.
+    fence = "`" * max([3] + [len(run) + 1 for run in re.findall(r"`+", diff)])
+    # In <code>, the "@BBL" of a filament file name does not mention a GitHub user.
+    def code(text):
+        return f"<code>{html.escape(text, quote=False)}</code>"
+    names, listing = ", ".join(map(code, files)), ""
+    if len(files) > GCODE_DIFF_SUMMARY_FILES + 1:  # never "and 1 more"
+        listing = f"<p>{names}</p>\n\n"  # an HTML block, so markdown in names stays literal
+        names = (", ".join(map(code, files[:GCODE_DIFF_SUMMARY_FILES]))
+                 + f" and {len(files) - GCODE_DIFF_SUMMARY_FILES} more")
+    return (f"\n<details>\n<summary><b>{names} - {code(setting)} (click to expand)</b>"
+            f"</summary>\n\n{listing}{fence}diff\n{diff}\n{fence}\n\n</details>\n")
+
+
+def gcode_diff(profiles_dir, base, head=None, vendors=None):
+    """Markdown with one collapsed diff per changed G-code setting between base and
+    head, or "" when none changed. Files whose diff of a setting is identical share
+    one section. Cut to whole sections under GCODE_DIFF_BUDGET."""
+    pairs = [(old, new) for old, new in _changed_profiles(profiles_dir, base, head)
+             if not vendors or any(p and p.split("/")[0] in vendors for p in (old, new))]
+    specs = ([(base, old) for old, _ in pairs if old]
+             + [(head, new) for _, new in pairs if new and head])
+    blobs = _blobs_at(profiles_dir, specs) if specs else {}
+
+    def load(ref, rel):
+        if rel is None:
+            return {}
+        if ref:
+            return _parse_profile(blobs[(ref, rel)], rel, ref)
+        try:
+            return _parse_profile(Path(profiles_dir, rel).read_bytes(), rel, "the working tree")
+        except OSError as e:
+            print_warning(f"{rel}: skipped, cannot read it: {e}", file=sys.stderr)
+            return None
+
+    groups = {}  # (setting, diff) -> files, in the order git lists them
+    for old_rel, new_rel in pairs:
+        old, new = load(base, old_rel), load(head, new_rel)
+        if not isinstance(old, dict) or not isinstance(new, dict):
+            continue
+        for setting, diff in _text_changes(old, new):
+            groups.setdefault((setting, diff), []).append(new_rel or old_rel)
+    if not groups:
+        return ""
+
+    sections = [_gcode_diff_section(files, setting, diff)
+                for (setting, diff), files in groups.items()]
+    budget = GCODE_DIFF_BUDGET - len(GCODE_DIFF_HEADER.encode("utf-8"))
+    shown = 0
+    for section in sections:
+        budget -= len(section.encode("utf-8"))
+        if budget < 0:
+            break
+        shown += 1
+    note, hidden = "", len(sections) - shown
+    if hidden:
+        note = (f"\n{hidden} of {len(sections)} sections {'is' if hidden == 1 else 'are'} not "
+                "shown because the comment would be too long for GitHub. See the Files "
+                "changed tab for the rest.\n")
+    return GCODE_DIFF_HEADER + "".join(sections[:shown]) + note
+
+
+def _default_gcode_diff_base(profiles_dir, head):
+    for main in ("upstream/main", "origin/main"):
+        try:
+            return _git(profiles_dir, "merge-base", head or "HEAD", main).decode().strip()
+        except subprocess.CalledProcessError:
+            continue
+    raise RuntimeError("no --base given, and neither upstream/main nor origin/main exists")
+
+
+def run_gcode_diff(profiles_dir, vendors, base, head):
+    try:
+        markdown = gcode_diff(profiles_dir, base or _default_gcode_diff_base(profiles_dir, head),
+                              head, vendors)
+    # UnicodeDecodeError means git listed a file name that is not UTF-8.
+    except (OSError, RuntimeError, UnicodeDecodeError, subprocess.CalledProcessError) as e:
+        stderr = getattr(e, "stderr", None)
+        print_error(stderr.decode(errors="replace").strip() if stderr else str(e), file=sys.stderr)
+        return 1
+    sys.stdout.write(markdown)
+    return 0
+
+
 # ---------------------------------------------------------------------------
 # CLI
 # ---------------------------------------------------------------------------
@@ -3233,6 +3455,9 @@ examples:
   orca_profile_tool.py legacy-compat --base /tmp/v2.4.2/resources/profiles
       rewrite resources/info/legacy_compatible_printers.json against 2.4.2's
       profiles (git archive v2.4.2 resources/profiles | tar -x -C /tmp/v2.4.2)
+  orca_profile_tool.py gcode-diff > gcode.md
+      the changed custom G-code of the working tree since it left upstream/main,
+      as markdown with one collapsed diff per setting
 
 after adding, renaming or deleting profile files, run in this order:
   normalize -> update-index -> generate-id -> check
@@ -3387,6 +3612,25 @@ def build_parser():
     legacy_cmd.add_argument("--check", action="store_true",
                             help="fail if the map differs from what --base implies; write nothing")
 
+    gcode_cmd = add(
+        "gcode-diff", [vendor_opt, profiles_opt],
+        "print a readable markdown diff of changed custom G-code",
+        "Print, as markdown, a unified diff of every G-code or other multi-line\n"
+        "setting that differs between --base and --head in each changed profile\n"
+        "file, one collapsed section per setting. Files whose diff of a setting is\n"
+        "identical share a section. Trailing spaces are removed from every line, and\n"
+        "the output is cut to whole sections to fit a GitHub comment. Prints nothing\n"
+        "when no such setting changed. CI posts it on profile PRs.\n"
+        "\n"
+        "The settings are the *_gcode and multiline string options PrintConfig.cpp\n"
+        "defines, the options Tab.cpp edits as code (such as filename_format), and any\n"
+        "string value that spans several lines.")
+    gcode_cmd.add_argument("--base", metavar="REF",
+                           help="compare against this git ref (default: the merge base "
+                                "with upstream/main, else origin/main)")
+    gcode_cmd.add_argument("--head", metavar="REF",
+                           help="compare this git ref (default: the working tree)")
+
     return parser
 
 
@@ -3423,6 +3667,9 @@ def main(argv=None):
     if args.command == "legacy-compat":
         return run_legacy_compat(args.base, profiles_dir, args.output, args.check)
 
+    if args.command == "gcode-diff":
+        return run_gcode_diff(profiles_dir, vendors, args.base, args.head)
+
     if args.command == "fix-variant":
         _changed, errors = fix_variant_arrays(profiles_dir, vendors, dry_run=args.dry_run,
                                                strict=args.strict)

scripts/tests/test_profile_tool.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """Tests for the tree-maintenance half of scripts/orca_profile_tool.py: the
-normalize, trim, update-index, fix-variant and check commands, and the subcommand
+normalize, trim, update-index, fix-variant, check and gcode-diff commands, and the
-dispatch that reaches them (stdlib unittest, no external deps).
+subcommand dispatch that reaches them (stdlib unittest, no external deps).
 
 The id halves are covered by test_filament_id.py and test_setting_id.py.
 
@@ -14,9 +14,12 @@ import json
 import os
 import re
 import shutil
+import stat
+import subprocess
 import sys
 import tempfile
 import unittest
+from unittest import mock
 
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 
@@ -41,7 +44,24 @@ class Tree:
         os.makedirs(self.profiles)
 
     def cleanup(self):
-        shutil.rmtree(self.dir, ignore_errors=True)
+        root = os.path.abspath(self.dir)
+
+        def writable_retry(func, path, _exc):
+            # Windows refuses to delete read-only files such as git's objects, and POSIX
+            # refuses to delete the entries of a read-only directory.
+            if not os.path.lexists(path):  # already removed, as on a second cleanup
+                return
+            parent = os.path.dirname(os.path.abspath(path))
+            try:
+                if os.path.commonpath([parent, root]) == root:  # never the temp dir itself
+                    os.chmod(parent, stat.S_IRWXU)
+                if not os.path.islink(path):  # chmod would follow it out of the tree
+                    os.chmod(path, stat.S_IRWXU)
+                func(path)
+            except (OSError, ValueError):  # commonpath raises ValueError across drives
+                pass
+        hook = "onexc" if sys.version_info >= (3, 12) else "onerror"
+        shutil.rmtree(self.dir, **{hook: writable_retry})
 
     def index_path(self, vendor):
         return os.path.join(self.profiles, vendor + ".json")
@@ -1409,6 +1429,292 @@ class TestDispatch(TreeCase):
         self.assertEqual(self.t.read("V", "filament/A.json")["type"], "filament")
 
 
+# ---------------------------------------------------------------------------
+# gcode-diff
+# ---------------------------------------------------------------------------
+
+@unittest.skipUnless(shutil.which("git"), "git not installed")
+class TestGcodeDiff(TreeCase):
+    START = "G28\nM104 S200\nG1 Z5"
+
+    def git(self, *args):
+        subprocess.run(["git", "-C", self.t.dir, "-c", "user.name=t", "-c", "user.email=t@t",
+                        "-c", "commit.gpgsign=false", *args], check=True, capture_output=True)
+
+    def printer(self, name, **extra):
+        self.t.write("V", f"machine/{name}.json", {"type": "machine", "name": name, **extra})
+
+    def commit(self):
+        self.git("add", "-A")
+        self.git("commit", "-q", "--allow-empty", "-m", "x")
+
+    @classmethod
+    def setUpClass(cls):
+        # git's list of the variables that tie a process to a repository, asked with no
+        # GIT_* set since a stray GIT_DIR fails the query.
+        clean = {k: v for k, v in os.environ.items() if not k.startswith("GIT_")}
+        cls.repo_env_vars = set(subprocess.run(
+            ["git", "rev-parse", "--local-env-vars"], env=clean, check=True,
+            capture_output=True, text=True).stdout.split())
+
+    def setUp(self):
+        super().setUp()
+        # A git hook's GIT_DIR or GIT_INDEX_FILE would point every git call here, the
+        # tool's included, at the real repository instead of the temp tree.
+        env = {k: v for k, v in os.environ.items() if k not in self.repo_env_vars}
+        patcher = mock.patch.dict(os.environ, env, clear=True)
+        patcher.start()
+        self.addCleanup(patcher.stop)
+        self.git("init", "-q")
+        for name in ("A", "B", "C"):
+            self.printer(name, machine_start_gcode=self.START, nozzle_diameter=["0.4"])
+        self.printer("Gone", machine_end_gcode="M84")
+        self.commit()
+
+    def diff(self):
+        rc, out = self.run_command("gcode-diff", "--base", "HEAD")
+        self.assertEqual(rc, 0, out)
+        return out
+
+    def test_identical_edits_share_one_section(self):
+        for name in ("A", "B"):
+            self.printer(name, machine_start_gcode="G28\nM104 S210  \nG1 Z5")
+        self.printer("C", machine_start_gcode="G28\nM104 S220\nG1 Z5")
+        out = self.diff()
+        self.assertEqual(out.count("<details>"), 2)
+        self.assertIn("<code>V/machine/A.json</code>, <code>V/machine/B.json</code> - "
+                      "<code>machine_start_gcode</code>", out)
+        self.assertIn("<code>V/machine/C.json</code> - <code>machine_start_gcode</code>", out)
+        # Trailing spaces are removed.
+        self.assertIn("\n-M104 S200\n+M104 S210\n", out)
+        self.assertIn("\n\n```diff\n@@ ", out)
+        self.assertIn("\n```\n\n</details>", out)
+
+    def test_nothing_is_printed_without_a_text_change(self):
+        self.printer("A", machine_start_gcode=self.START, nozzle_diameter=["0.6"])
+        self.assertEqual(self.diff(), "")
+
+    def test_added_and_deleted_files_show_the_whole_value(self):
+        # An untracked file counts as added; the validator's user dir is not a profile.
+        self.printer("New", machine_start_gcode="G28\nG29")
+        self.t.write("user", "default/machine/U.json", {"machine_start_gcode": "G28"})
+        os.remove(self.t.path("V", "machine/Gone.json"))
+        out = self.diff()
+        self.assertIn("@@ -0,0 +1,2 @@\n+G28\n+G29\n", out)
+        self.assertIn("<code>V/machine/Gone.json</code> - <code>machine_end_gcode</code>", out)
+        self.assertIn("@@ -1 +0,0 @@\n-M84\n", out)
+        self.assertNotIn("U.json", out)
+
+    def test_a_multi_line_value_counts_whatever_its_key(self):
+        self.printer("A", machine_start_gcode=self.START, custom_note="one\ntwo")
+        self.assertIn("<code>V/machine/A.json</code> - <code>custom_note</code>", self.diff())
+
+    def test_a_file_name_cannot_mention_a_user(self):
+        self.t.write("V", "filament/PLA @BBL A1.json", {"filament_start_gcode": ["M106"]})
+        self.assertIn("<code>V/filament/PLA @BBL A1.json</code>", self.diff())
+
+    def test_head_compares_two_commits(self):
+        self.printer("A", machine_start_gcode="G28")
+        self.commit()
+        rc, out = self.run_command("gcode-diff", "--base", "HEAD~1", "--head", "HEAD")
+        self.assertEqual(rc, 0, out)
+        self.assertIn("<code>V/machine/A.json</code> - <code>machine_start_gcode</code>", out)
+
+    def test_a_renamed_file_diffs_against_its_old_self(self):
+        os.rename(self.t.path("V", "machine/A.json"), self.t.path("V", "machine/A2.json"))
+        self.printer("A2", machine_start_gcode="G28\nM104 S210\nG1 Z5", nozzle_diameter=["0.4"])
+        self.commit()
+        rc, out = self.run_command("gcode-diff", "--base", "HEAD~1", "--head", "HEAD")
+        self.assertEqual(rc, 0, out)
+        self.assertIn("<code>V/machine/A2.json</code> - <code>machine_start_gcode</code>", out)
+        self.assertIn("\n G28\n-M104 S200\n+M104 S210\n G1 Z5\n", out)
+
+    def test_a_file_renamed_off_json_loses_its_values(self):
+        os.rename(self.t.path("V", "machine/Gone.json"), self.t.path("V", "machine/Gone.json.bak"))
+        self.commit()
+        rc, out = self.run_command("gcode-diff", "--base", "HEAD~1", "--head", "HEAD")
+        self.assertEqual(rc, 0, out)
+        self.assertIn("<code>V/machine/Gone.json</code> - <code>machine_end_gcode</code>", out)
+        self.assertIn("@@ -1 +0,0 @@\n-M84\n", out)
+
+    def test_a_file_renamed_onto_json_is_new(self):
+        with open(self.t.path("V", "machine/Draft.txt"), "w", encoding="utf-8") as f:
+            json.dump({"type": "machine", "machine_start_gcode": self.START}, f)
+        self.commit()
+        os.rename(self.t.path("V", "machine/Draft.txt"), self.t.path("V", "machine/Draft.json"))
+        self.commit()
+        rc, out = self.run_command("gcode-diff", "--base", "HEAD~1", "--head", "HEAD")
+        self.assertEqual(rc, 0, out)
+        self.assertIn("@@ -0,0 +1,3 @@\n+G28\n+M104 S200\n+G1 Z5\n", out)
+
+    def test_a_batch_read_survives_paths_that_are_not_files(self):
+        blobs = apt._blobs_at(self.t.profiles, [("HEAD", "V/machine"), ("HEAD", "V/no such.json"),
+                                                ("HEAD", "V/machine/Gone.json")])
+        self.assertIsNone(blobs[("HEAD", "V/machine")])
+        self.assertIsNone(blobs[("HEAD", "V/no such.json")])
+        self.assertEqual(json.loads(blobs[("HEAD", "V/machine/Gone.json")])["machine_end_gcode"],
+                         "M84")
+
+    def test_each_value_of_a_vector_option_is_its_own_setting(self):
+        self.t.write("V", "filament/F.json", {"filament_start_gcode": ["M106", "M107"]})
+        self.commit()
+        self.t.write("V", "filament/F.json", {"filament_start_gcode": ["M106", "M106 S0"]})
+        out = self.diff()
+        self.assertEqual(out.count("<details>"), 1)
+        self.assertIn("<code>filament_start_gcode[1]</code>", out)
+
+    def test_vendor_limits_the_files(self):
+        self.printer("A", machine_start_gcode="G28")
+        self.t.write("W", "machine/X.json", {"machine_start_gcode": "G28"})
+        rc, out = self.run_command("gcode-diff", "--base", "HEAD", "--vendor", "V")
+        self.assertEqual(rc, 0, out)
+        self.assertIn("V/machine/A.json", out)
+        self.assertNotIn("W/machine/X.json", out)
+
+    def test_vendor_includes_files_moved_out_of_it(self):
+        self.t.add_vendor("W")
+        os.rename(self.t.path("V", "machine/A.json"), self.t.path("W", "machine/A.json"))
+        data = self.t.read("W", "machine/A.json")
+        self.t.write("W", "machine/A.json", {**data, "machine_start_gcode": "G28\nM104 S210\nG1 Z5"})
+        self.commit()
+        rc, out = self.run_command("gcode-diff", "--base", "HEAD~1", "--head", "HEAD",
+                                   "--vendor", "V")
+        self.assertEqual(rc, 0, out)
+        self.assertIn("<code>W/machine/A.json</code> - <code>machine_start_gcode</code>", out)
+
+    def same_edit(self, names):
+        """The diff after one start G-code edit to each of names; returns (summary, output)."""
+        for name in names:
+            self.printer(name, machine_start_gcode=self.START, nozzle_diameter=["0.4"])
+        self.commit()
+        for name in names:
+            self.printer(name, machine_start_gcode="G28")
+        out = self.diff()
+        return re.search(r"<summary>(.*)</summary>", out).group(1), out
+
+    def test_a_long_file_list_moves_into_the_section(self):
+        summary, out = self.same_edit("ABCDE")
+        self.assertIn("<code>V/machine/C.json</code> and 2 more - ", summary)
+        self.assertNotIn("D.json", summary)
+        self.assertIn("<code>V/machine/D.json</code>, <code>V/machine/E.json</code></p>\n\n```diff",
+                      out)
+
+    def test_four_files_are_all_named_in_the_summary(self):
+        summary, _out = self.same_edit("ABCD")
+        self.assertIn("<code>V/machine/D.json</code> - ", summary)
+        self.assertNotIn("more", summary)
+
+    def test_an_error_goes_to_stderr_only(self):
+        err = io.StringIO()
+        with contextlib.redirect_stderr(err):
+            rc, out = self.run_command("gcode-diff", "--base", "no-such-ref")
+        self.assertEqual(rc, 1)
+        self.assertEqual(out, "")
+        self.assertIn("no-such-ref", err.getvalue())
+
+    def test_a_file_name_that_is_not_utf8_is_an_error(self):
+        bad = UnicodeDecodeError("utf-8", b"\xe9.json", 0, 1, "invalid continuation byte")
+        err = io.StringIO()
+        with mock.patch.object(apt, "_changed_profiles", side_effect=bad), \
+                contextlib.redirect_stderr(err):
+            rc, out = self.run_command("gcode-diff", "--base", "HEAD")
+        self.assertEqual((rc, out), (1, ""))
+        self.assertIn("invalid continuation byte", err.getvalue())
+
+    def test_output_is_cut_to_whole_sections(self):
+        for name in ("A", "B", "C"):
+            self.printer(name, machine_start_gcode=name * 300)
+        size = len(apt.gcode_diff(self.t.profiles, "HEAD").encode("utf-8"))
+        with mock.patch.object(apt, "GCODE_DIFF_BUDGET", size - 1):
+            out = self.diff()
+        self.assertEqual(out.count("<details>"), 2)
+        self.assertEqual(out.count("</details>"), 2)
+        self.assertIn("\n1 of 3 sections is not shown", out)
+        with mock.patch.object(apt, "GCODE_DIFF_BUDGET", 1):
+            self.assertIn("\n3 of 3 sections are not shown", self.diff())
+
+    def test_cleanup_removes_the_repo(self):
+        # setUp's commit leaves read-only git objects, and a read-only directory blocks
+        # deletion on POSIX.
+        os.chmod(self.t.path("V", "machine"), stat.S_IRUSR | stat.S_IXUSR)
+        self.t.cleanup()
+        self.assertFalse(os.path.exists(self.t.dir))
+        with mock.patch.object(os, "chmod") as chmod:
+            self.t.cleanup()  # a second cleanup, as addCleanup runs, must not touch the temp dir
+        chmod.assert_not_called()
+
+    def test_only_repository_variables_are_stripped(self):
+        self.assertTrue({"GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE"} <= self.repo_env_vars)
+        self.assertFalse({"GIT_SSH", "GIT_EXEC_PATH", "GIT_EDITOR"} & self.repo_env_vars)
+
+    def test_cleanup_leaves_symlink_targets_alone(self):
+        outside = tempfile.mkdtemp(prefix="profile_tool_outside_")
+        self.addCleanup(shutil.rmtree, outside, True)
+        target = os.path.join(outside, "f")
+        open(target, "w").close()
+        os.chmod(target, stat.S_IRUSR)
+        self.addCleanup(os.chmod, target, stat.S_IRWXU)  # runs before the rmtree above
+        machine = self.t.path("V", "machine")
+        try:
+            os.symlink(target, os.path.join(machine, "link"))
+        except (OSError, NotImplementedError):
+            self.skipTest("cannot create symlinks here")
+        os.chmod(machine, stat.S_IRUSR | stat.S_IXUSR)  # so removing the link fails at first
+        self.t.cleanup()
+        self.assertFalse(os.path.exists(self.t.dir))
+        self.assertEqual(stat.S_IMODE(os.stat(target).st_mode) & stat.S_IWUSR, 0)
+
+    def test_a_git_hook_environment_is_ignored(self):
+        scripts = os.path.join(REPO_ROOT, "scripts")
+        result = subprocess.run(
+            [sys.executable, "-m", "unittest",
+             "tests.test_profile_tool.TestGcodeDiff.test_head_compares_two_commits"],
+            cwd=scripts, capture_output=True, text=True,
+            env={**os.environ, "GIT_DIR": os.path.join(self.t.dir, "nowhere")})
+        self.assertEqual(result.returncode, 0, result.stderr)
+
+    def test_the_options_are_read_from_the_engine(self):
+        keys = apt._text_option_keys()
+        self.assertTrue({"machine_start_gcode", "filament_start_gcode", "printing_by_object_gcode",
+                         "notes", "post_process"} <= keys)
+        self.assertNotIn("emit_machine_limits_to_gcode", keys)  # a coBool
+
+    START_DEF = 'def = this->add("machine_start_gcode", coString);\n'
+
+    def keys_from(self, print_config, tab=None):
+        """_text_option_keys read from these sources; no tab means no Tab.cpp."""
+        paths = [os.path.join(self.t.dir, "PrintConfig.cpp"), os.path.join(self.t.dir, "Tab.cpp")]
+        for path, text in zip(paths, (print_config, tab)):
+            if text is not None:
+                with open(path, "w", encoding="utf-8") as f:
+                    f.write(text)
+        apt._text_option_keys.cache_clear()
+        self.addCleanup(apt._text_option_keys.cache_clear)
+        with mock.patch.object(apt, "PRINT_CONFIG_CPP", paths[0]), \
+                mock.patch.object(apt, "TAB_CPP", paths[1]):
+            return apt._text_option_keys()
+
+    def test_multiline_is_read_whatever_its_spacing(self):
+        keys = self.keys_from(self.START_DEF + 'def = this->add("printer_notes", coString);\n'
+                                               '    def->multiline  = true;\n')
+        self.assertIn("printer_notes", keys)
+
+    def test_the_code_options_of_tab_cpp_are_read(self):
+        keys = self.keys_from(self.START_DEF, 'option = optgroup->get_option("filename_format");\n'
+                                              'option.opt.is_code = true;\n'
+                                              'option = optgroup->get_option("layer_height");\n')
+        self.assertIn("filename_format", keys)
+        self.assertNotIn("layer_height", keys)
+
+    def test_a_missing_tab_cpp_is_not_an_error(self):
+        self.assertIn("machine_start_gcode", self.keys_from(self.START_DEF))
+
+    def test_markdown_in_a_file_name_stays_literal(self):
+        section = apt._gcode_diff_section(["V/a *b*.json", "V/c.json", "V/d.json", "V/e.json",
+                                           "V/f.json"], "machine_start_gcode", "@@ -1 +1 @@")
+        self.assertIn("\n<p><code>V/a *b*.json</code>, ", section)
+
+
 # ---------------------------------------------------------------------------
 # the real tree
 # ---------------------------------------------------------------------------

src/OrcaSlicer.cpp

@@ -1126,6 +1126,19 @@ static void load_downward_settings_list_from_config(std::string config_file, std
     }
 }
 
+#ifdef __WXGTK__
+// Virtual GPUs (VirtualBox, VMware, QEMU) cannot back WebKit's hardware DMABUF renderer.
+static bool is_hypervisor_guest()
+{
+    std::ifstream cpuinfo("/proc/cpuinfo");
+    std::string line;
+    while (std::getline(cpuinfo, line))
+        if (boost::starts_with(line, "flags"))
+            return line.find(" hypervisor") != std::string::npos;
+    return false;
+}
+#endif
+
 int CLI::run(int argc, char **argv)
 {
     // Mark the main thread for the debugger and for runtime checks.
@@ -1176,6 +1189,9 @@ int CLI::run(int argc, char **argv)
             ::setenv("WEBKIT_FORCE_DMABUF_RENDERER", "1", /* replace */ false);
         }
 
+        if (is_hypervisor_guest() && WebView::SupportsForceSharedMemory())
+            ::setenv("WEBKIT_DMABUF_RENDERER_FORCE_SHM", "1", /* replace */ false);
+
         if (x11_opt_in) {
             // ===== X11 / XWayland (opted in via GDK_BACKEND=x11) =====
             BOOST_LOG_TRIVIAL(info) << "GDK_BACKEND=x11 detected; applying v2.3.2 X11/XWayland workarounds.";

src/libslic3r/Arachne/WallToolPaths.cpp

@@ -812,7 +812,8 @@ bool WallToolPaths::removeEmptyToolPaths(std::vector<VariableWidthLines> &toolpa
      * Get the order constraints of the insets when printing walls per region / hole.
      * Each returned pair consists of adjacent wall lines where the left has an inset_idx one lower than the right.
      *
-     * Odd walls should always go after their enclosing wall polygons.
+     * Odd walls follow the same order as even ones, so that the centre line of a narrow wall is an inner wall
+     * like any other when printing inner to outer.
      *
      * \param outer_to_inner Whether the wall polygons with a lower inset_idx should go before those with a higher one.
  */
@@ -886,12 +887,7 @@ WallToolPaths::ExtrusionLineSet WallToolPaths::getRegionOrder(const std::vector<
                 continue; // not directly adjacent
             if (!shorter_then(loc_here - lineloc_nearby.j.p, (lineloc_here.j.w + lineloc_nearby.j.w) / 2 * diagonal_extension))
                 continue; // points are too far away from each other
-            if (here->is_odd || nearby->is_odd) {
+            if ((nearby->inset_idx < here->inset_idx) == outer_to_inner) {
-                if (here->is_odd && !nearby->is_odd && nearby->inset_idx < here->inset_idx)
-                    order_requirements.emplace(std::make_pair(nearby, here));
-                if (nearby->is_odd && !here->is_odd && here->inset_idx < nearby->inset_idx)
-                    order_requirements.emplace(std::make_pair(here, nearby));
-            } else if ((nearby->inset_idx < here->inset_idx) == outer_to_inner) {
                 order_requirements.emplace(std::make_pair(nearby, here));
             } else {
                 assert((nearby->inset_idx > here->inset_idx) == outer_to_inner);

src/libslic3r/GCode.cpp

@@ -3985,6 +3985,16 @@ void GCode::_do_export(Print& print, GCodeOutputStream &file, ThumbnailsGenerato
     this->placeholder_parser().set("print_time_minute", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Minute_Placeholder)));
     this->placeholder_parser().set("print_time_sec", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Print_Time_Sec_Placeholder)));
     this->placeholder_parser().set("used_filament_length", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Used_Filament_Length_Placeholder)));
+    // The final print statistics are known only after the whole G-code is generated, so they are filled in during post-processing too.
+    // The running extruded_* totals are left alone; profiles use them as numbers.
+    this->placeholder_parser().set("used_filament", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Used_Filament_Length_Placeholder)));
+    this->placeholder_parser().set("print_time", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Normal_Print_Time_Placeholder)));
+    this->placeholder_parser().set("normal_print_time", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Normal_Print_Time_Placeholder)));
+    this->placeholder_parser().set("silent_print_time", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Silent_Print_Time_Placeholder)));
+    this->placeholder_parser().set("total_weight", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Weight_Placeholder)));
+    this->placeholder_parser().set("total_cost", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Cost_Placeholder)));
+    this->placeholder_parser().set("total_wipe_tower_cost", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Wipe_Tower_Cost_Placeholder)));
+    this->placeholder_parser().set("total_wipe_tower_filament", new ConfigOptionString(GCodeProcessor::reserved_tag(GCodeProcessor::ETags::Total_Wipe_Tower_Filament_Placeholder)));
 
     // Sync variant-mapped params into placeholder_parser before processing start gcode
     update_placeholder_parser_with_variant_params();

src/libslic3r/GCode/GCodeProcessor.cpp

@@ -120,7 +120,13 @@ const std::vector<std::string> GCodeProcessor::Reserved_Tags = {
     "@PRINT_TIME_HOUR@",
     "@PRINT_TIME_MINUTE@",
     "@PRINT_TIME_SEC@",
-    "@USED_FILAMENT_LENGTH@"
+    "@USED_FILAMENT_LENGTH@",
+    "@NORMAL_PRINT_TIME@",
+    "@SILENT_PRINT_TIME@",
+    "@TOTAL_WEIGHT@",
+    "@TOTAL_COST@",
+    "@TOTAL_WIPE_TOWER_COST@",
+    "@TOTAL_WIPE_TOWER_FILAMENT@"
 };
 
 const std::vector<std::string> GCodeProcessor::Reserved_Tags_compatible = {
@@ -147,7 +153,13 @@ const std::vector<std::string> GCodeProcessor::Reserved_Tags_compatible = {
     "@PRINT_TIME_HOUR@",
     "@PRINT_TIME_MINUTE@",
     "@PRINT_TIME_SEC@",
-    "@USED_FILAMENT_LENGTH@"
+    "@USED_FILAMENT_LENGTH@",
+    "@NORMAL_PRINT_TIME@",
+    "@SILENT_PRINT_TIME@",
+    "@TOTAL_WEIGHT@",
+    "@TOTAL_COST@",
+    "@TOTAL_WIPE_TOWER_COST@",
+    "@TOTAL_WIPE_TOWER_FILAMENT@"
 };
 
 
@@ -1264,19 +1276,22 @@ void GCodeProcessor::run_post_process()
         return ret;
     };
 
-    // Process inline placeholders (print_time_total_sec, print_time_day, print_time_hour, print_time_minute, print_time_sec and used_filament_length)
+    // Process inline placeholders (print_time_*, used_filament_length and the print statistics known only after export)
     auto process_inline_placeholders = [&](std::string& gcode_line) {
         bool processed = false;
         // Every inline placeholder contains '@', so a line without one has nothing to replace.
         if (gcode_line.find('@') == std::string::npos)
             return processed;
 
-        const std::string& print_time_total_placeholder = reserved_tag(ETags::Print_Time_Total_Sec_Placeholder);
+        auto replace_tag = [&gcode_line, &processed](ETags tag, const std::string& value) {
-        const std::string& print_time_day_placeholder = reserved_tag(ETags::Print_Time_Day_Placeholder);
+            const std::string& placeholder = reserved_tag(tag);
-        const std::string& print_time_hour_placeholder = reserved_tag(ETags::Print_Time_Hour_Placeholder);
+            size_t pos = gcode_line.find(placeholder);
-        const std::string& print_time_minute_placeholder = reserved_tag(ETags::Print_Time_Minute_Placeholder);
+            while (pos != std::string::npos) {
-        const std::string& print_time_sec_placeholder = reserved_tag(ETags::Print_Time_Sec_Placeholder);
+                gcode_line.replace(pos, placeholder.length(), value);
-        const std::string& used_filament_placeholder = reserved_tag(ETags::Used_Filament_Length_Placeholder);
+                processed = true;
+                pos = gcode_line.find(placeholder, pos + value.length());
+            }
+        };
 
         double print_time_total_sec = m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Normal)].time;
         if (print_time_total_sec < 0.0)
@@ -1289,70 +1304,31 @@ void GCodeProcessor::run_post_process()
         int print_time_minute = (day_remainder_seconds % 3600) / 60;
         int print_time_sec = day_remainder_seconds % 60;
 
-        // Replace print_time_total_sec
+        double total_filament_mm = 0.0;
-        size_t pos = gcode_line.find(print_time_total_placeholder);
+        for (const auto& mm : filament_mm) {
-        while (pos != std::string::npos) {
+            total_filament_mm += mm;
-            char buf[64];
-            sprintf(buf, "%.2f", print_time_total_sec);
-            gcode_line.replace(pos, print_time_total_placeholder.length(), buf);
-            processed = true;
-            pos = gcode_line.find(print_time_total_placeholder, pos + strlen(buf));
         }
 
-        // Replace print_time_day
+        replace_tag(ETags::Print_Time_Total_Sec_Placeholder, Slic3r::float_to_string_decimal_point(print_time_total_sec, 2));
-        pos = gcode_line.find(print_time_day_placeholder);
+        replace_tag(ETags::Print_Time_Day_Placeholder, std::to_string(print_time_day));
-        while (pos != std::string::npos) {
+        replace_tag(ETags::Print_Time_Hour_Placeholder, std::to_string(print_time_hour));
-            char buf[64];
+        replace_tag(ETags::Print_Time_Minute_Placeholder, std::to_string(print_time_minute));
-            sprintf(buf, "%d", print_time_day);
+        replace_tag(ETags::Print_Time_Sec_Placeholder, std::to_string(print_time_sec));
-            gcode_line.replace(pos, print_time_day_placeholder.length(), buf);
+        replace_tag(ETags::Used_Filament_Length_Placeholder,
-            processed = true;
+                    Slic3r::float_to_string_decimal_point(total_filament_mm / 1000.0, 2)); // Convert mm to m
-            pos = gcode_line.find(print_time_day_placeholder, pos + strlen(buf));
+        // Same values as the print statistics that filename_format gets (PrintStatistics::config(), filled in by
-        }
+        // update_print_estimated_stats() in GCode.cpp), which runs only after this post-processing.
-
+        replace_tag(ETags::Normal_Print_Time_Placeholder, get_time_dhm(PrintEstimatedStatistics::ETimeMode::Normal));
-        // Replace print_time_hour
+        replace_tag(ETags::Silent_Print_Time_Placeholder, is_stealth_time_estimator_enabled() ?
-        pos = gcode_line.find(print_time_hour_placeholder);
+                                                              get_time_dhm(PrintEstimatedStatistics::ETimeMode::Stealth) :
-        while (pos != std::string::npos) {
+                                                              short_time("N/A"));
-            char buf[64];
+        const double total_cost = filament_total_cost + m_print->config().time_cost.value * print_time_total_sec / 3600.0;
-            sprintf(buf, "%d", print_time_hour);
+        replace_tag(ETags::Total_Weight_Placeholder, Slic3r::float_to_string_decimal_point(filament_total_g, 2));
-            gcode_line.replace(pos, print_time_hour_placeholder.length(), buf);
+        replace_tag(ETags::Total_Cost_Placeholder, Slic3r::float_to_string_decimal_point(total_cost, 2));
-            processed = true;
+        replace_tag(ETags::Total_Wipe_Tower_Cost_Placeholder,
-            pos = gcode_line.find(print_time_hour_placeholder, pos + strlen(buf));
+                    Slic3r::float_to_string_decimal_point(m_print->print_statistics().total_wipe_tower_cost, 2));
-        }
+        replace_tag(ETags::Total_Wipe_Tower_Filament_Placeholder,
-
+                    Slic3r::float_to_string_decimal_point(m_print->print_statistics().total_wipe_tower_filament, 2));
-        // Replace print_time_minute
-        pos = gcode_line.find(print_time_minute_placeholder);
-        while (pos != std::string::npos) {
-            char buf[64];
-            sprintf(buf, "%d", print_time_minute);
-            gcode_line.replace(pos, print_time_minute_placeholder.length(), buf);
-            processed = true;
-            pos = gcode_line.find(print_time_minute_placeholder, pos + strlen(buf));
-        }
-
-        // Replace print_time_sec
-        pos = gcode_line.find(print_time_sec_placeholder);
-        while (pos != std::string::npos) {
-            char buf[64];
-            sprintf(buf, "%d", print_time_sec);
-            gcode_line.replace(pos, print_time_sec_placeholder.length(), buf);
-            processed = true;
-            pos = gcode_line.find(print_time_sec_placeholder, pos + strlen(buf));
-        }
-
-        // Replace used_filament_length
-        pos = gcode_line.find(used_filament_placeholder);
-        while (pos != std::string::npos) {
-            double total_filament_mm = 0.0;
-            for (const auto& mm : filament_mm) {
-                total_filament_mm += mm;
-            }
-            double used_filament_length = total_filament_mm / 1000.0; // Convert mm to m
-            char buf[64];
-            sprintf(buf, "%.2f", used_filament_length);
-            gcode_line.replace(pos, used_filament_placeholder.length(), buf);
-            processed = true;
-            pos = gcode_line.find(used_filament_placeholder, pos + strlen(buf));
-        }
 
         return processed;
     };

src/libslic3r/GCode/GCodeProcessor.hpp

@@ -601,6 +601,12 @@ inline constexpr float DEFAULT_FILAMENT_DENSITY = 1.245f;
             Print_Time_Minute_Placeholder,
             Print_Time_Sec_Placeholder,
             Used_Filament_Length_Placeholder,
+            Normal_Print_Time_Placeholder,
+            Silent_Print_Time_Placeholder,
+            Total_Weight_Placeholder,
+            Total_Cost_Placeholder,
+            Total_Wipe_Tower_Cost_Placeholder,
+            Total_Wipe_Tower_Filament_Placeholder,
         };
 
         static const std::string& reserved_tag(ETags tag) { return s_IsBBLPrinter ? Reserved_Tags[static_cast<unsigned char>(tag)] : Reserved_Tags_compatible[static_cast<unsigned char>(tag)]; }

src/libslic3r/PerimeterGenerator.cpp

@@ -62,7 +62,12 @@ public:
     // Depth in the hierarchy. External perimeter has depth = 0. An external perimeter could be both a contour and a hole.
     unsigned short                      depth;
     // ORCA: an external hole perimeter touching the next outer wall all around, with nothing between them.
+    // E.g. a 1mm tube wall with 0.5mm walls: 2 lines, the contour's outer wall and the hole's.
     bool                                is_thin_wall_hole = false;
+    // ORCA: an external hole perimeter with no room for an inner wall beside it, at most gap fill. Every thin wall
+    // hole is one, and so is e.g. a 1.5mm tube wall with 0.5mm walls: 3 lines, the two outer walls and gap fill
+    // between them. A 2mm tube wall has room for an inner wall a side and is not. Only set for Inner/Outer/Inner.
+    bool                                is_narrow_wall_hole = false;
     // Children contour, may be both CCW and CW oriented (outer contours or holes).
     std::vector<PerimeterGeneratorLoop> children;
 
@@ -572,7 +577,8 @@ static ExtrusionEntityCollection traverse_extrusions(const PerimeterGenerator& p
                 extrusion_coll.append(std::move(extrusion_loop));
                 // Orca: Reverse the order of paths for thin wall holes. We define thin wall hole as a hole with only one perimeter.
                 const bool thin_wall_hole = !pg_extrusion.is_contour && pg_extrusions.size() == 2;
-                if (thin_wall_hole && perimeter_generator.config->wall_sequence != WallSequence::OuterInner)
+                if (thin_wall_hole && perimeter_generator.config->wall_sequence != WallSequence::OuterInner &&
+                    !perimeter_generator.outer_walls_first_for_brim())
                     std::reverse(extrusion_coll.entities.begin(), extrusion_coll.entities.end());
             }
             else {
@@ -1690,13 +1696,24 @@ void PerimeterGenerator::process_classic()
 
                 last = std::move(offsets);
 
-                // ORCA: a thin wall hole has no room for gap fill or an inner wall anywhere beside its outer wall.
+                // ORCA: a thin wall hole has no room for gap fill or an inner wall anywhere beside its outer wall, a
+                // narrow wall hole none for an inner wall, the room the next loop is offset by below.
                 if (i == 0 && ! holes[0].empty()) {
-                    const float    room  = float(0.5 * (ext_perimeter_spacing2 + gap_fill_min_width));
+                    auto reach = [&last](double room) {
-                    const Polygons reach = to_polygons(offset2_ex(last, -room, room + float(SCALED_EPSILON)));
+                        return to_polygons(offset2_ex(last, -float(room), float(room) + float(SCALED_EPSILON)));
-                    for (PerimeterGeneratorLoop &hole : holes[0])
+                    };
-                        hole.is_thin_wall_hole = intersection_pl(Polylines{ hole.polygon.split_at_first_point() },
+                    auto out_of_reach = [](const Polygon &hole, const Polygons &reach) {
-                            ClipperUtils::clip_clipper_polygons_with_subject_bbox(reach, get_extents(hole.polygon).inflated(SCALED_EPSILON))).empty();
+                        return intersection_pl(Polylines{ hole.split_at_first_point() },
+                            ClipperUtils::clip_clipper_polygons_with_subject_bbox(reach, get_extents(hole).inflated(SCALED_EPSILON))).empty();
+                    };
+                    // Only Inner/Outer/Inner orders narrow wall holes apart.
+                    const bool     narrow_holes_ordered = this->config->wall_sequence == WallSequence::InnerOuterInner;
+                    const Polygons gap_fill_reach       = reach(0.5 * (ext_perimeter_spacing2 + gap_fill_min_width));
+                    const Polygons inner_wall_reach     = narrow_holes_ordered ? reach(ext_perimeter_spacing2 + min_spacing / 2.) : Polygons();
+                    for (PerimeterGeneratorLoop &hole : holes[0]) {
+                        hole.is_thin_wall_hole   = out_of_reach(hole.polygon, gap_fill_reach);
+                        hole.is_narrow_wall_hole = narrow_holes_ordered && out_of_reach(hole.polygon, inner_wall_reach);
+                    }
                 }
 
                 //BBS: refer to superslicer
@@ -1835,18 +1852,16 @@ void PerimeterGenerator::process_classic()
 
             // if brim will be printed, reverse the order of perimeters so that
             // we continue inwards after having finished the brim
-            // TODO: add test for perimeter order
             bool is_outer_wall_first = this->config->wall_sequence == WallSequence::OuterInner;
-            if (is_outer_wall_first ||
+            // Orca: a contour with only a narrow wall hole beside it has nothing to sandwich, and prints the hole first,
-                //BBS: always print outer wall first when there indeed has brim.
+            // then the contour, then the gap fill between them, as Arachne does.
-                // btLeadingEdgeOnly is an outer brim too (a belt brim at the part's first contact).
+            const PerimeterGeneratorLoops &island_loops = contours.front();
-                (this->layer_id == 0 &&
+            const bool narrow_wall_hole_island = island_loops.size() == 1 && island_loops.front().children.size() == 1 &&
-                    (this->object_config->brim_type == BrimType::btOuterOnly ||
+                                                 island_loops.front().children.front().is_narrow_wall_hole;
-                     this->object_config->brim_type == BrimType::btLeadingEdgeOnly) &&
+            if (is_outer_wall_first || this->outer_walls_first_for_brim())
-                    this->object_config->brim_width.value > 0))
                 entities.reverse();
             // Orca: sandwich mode. Apply after 1st layer.
-            else if ((this->config->wall_sequence == WallSequence::InnerOuterInner) && layer_id > 0){
+            else if ((this->config->wall_sequence == WallSequence::InnerOuterInner) && layer_id > 0 && !narrow_wall_hole_island){
                 entities.reverse(); // reverse all entities - order them from external to internal
                 if(entities.entities.size()>2){ // 3 walls minimum needed to do inner outer inner ordering
                     int position = 0; // index to run the re-ordering for multiple external perimeters in a single island.
@@ -2412,11 +2427,25 @@ std::vector<PerimeterGeneratorArachneExtrusion> reorderPerimetersByProximity(std
 
     // Function to reorder perimeters starting from a given reference index
     auto reorderFromReference = [&](int referenceIndex) {
-        std::unordered_set<int> firstLevelIndices;
+        // Find first level touching perimeters. The odd centre line of a wall too narrow for two inner walls is shared
-        firstLevelIndices.insert(referenceIndex);
+        // by the outer walls on both sides, so those join this island and are printed before it too, holes first.
-
+        std::vector<int> outerIndices{referenceIndex};
-        // Find first level touching perimeters
+        std::vector<int> firstLevelTouchingIndices;
-        std::vector<int> firstLevelTouchingIndices = findAllTouchingPerimeters(entities, firstLevelIndices, threshold_external, threshold_internal, 1);
+        for (size_t next = 0; next < outerIndices.size(); ++next)
+            for (int idx : findAllTouchingPerimeters(entities, {outerIndices[next]}, threshold_external, threshold_internal, 1)) {
+                if (std::find(firstLevelTouchingIndices.begin(), firstLevelTouchingIndices.end(), idx) != firstLevelTouchingIndices.end())
+                    continue;
+                firstLevelTouchingIndices.push_back(idx);
+                if (!entities[idx].extrusion->is_odd)
+                    continue;
+                for (size_t i = 0; i < entities.size(); ++i)
+                    if (entities[i].extrusion->inset_idx == 0 && includedIndices.count(int(i)) == 0 &&
+                        std::find(outerIndices.begin(), outerIndices.end(), int(i)) == outerIndices.end() &&
+                        arachne_lines_touch(*entities[i].extrusion, *entities[idx].extrusion, double(threshold_external)))
+                        outerIndices.push_back(int(i));
+            }
+        std::stable_partition(outerIndices.begin(), outerIndices.end(),
+                              [&entities](int idx) { return entities[idx].extrusion->is_closed && !entities[idx].is_contour; });
         // Bring the largest first level perimeter to the front
         // The longest first neighbour is most likely the dominant proximate perimeter
         // hence printing it immediately after the external perimeter should speed things up
@@ -2427,8 +2456,10 @@ std::vector<PerimeterGeneratorArachneExtrusion> reorderPerimetersByProximity(std
             std::iter_swap(maxIt, firstLevelTouchingIndices.end() - 1);
         }
         // Insert first level perimeters into reordered list
-        reordered.push_back(entities[referenceIndex]);
+        for (int idx : outerIndices) {
-        includedIndices.insert(referenceIndex);
+            reordered.push_back(entities[idx]);
+            includedIndices.insert(idx);
+        }
 
         for (int idx : firstLevelTouchingIndices) {
             if (includedIndices.count(idx) == 0) {
@@ -2757,7 +2788,7 @@ void PerimeterGenerator::process_arachne()
         
         if (layer_id == 0){ // disable inner outer inner algorithm after the first layer
         	is_outer_wall_first =
-            	this->config->wall_sequence == WallSequence::OuterInner;
+            	this->config->wall_sequence == WallSequence::OuterInner || this->outer_walls_first_for_brim();
         }
         if (is_outer_wall_first) {
             start_perimeter = 0;
@@ -3042,6 +3073,16 @@ ExPolygons PerimeterGenerator::printable_slices(const ExPolygons &slices) const
     return min_width > EPSILON ? opening_ex(slices, float(scale_(min_width / 2.))) : slices;
 }
 
+bool PerimeterGenerator::outer_walls_first_for_brim() const
+{
+    return layer_id == 0 && brim_puts_outer_walls_first(object_config->brim_type.value, object_config->brim_width.value);
+}
+
+bool brim_puts_outer_walls_first(BrimType brim_type, double brim_width)
+{
+    return brim_width > 0 && (brim_type == btOuterOnly || brim_type == btOuterAndInner || brim_type == btLeadingEdgeOnly);
+}
+
 std::vector<Polygons> PerimeterGenerator::generate_lower_polygons_series(float width)
 {
     float nozzle_diameter = print_config->nozzle_diameter.get_at(config->outer_wall_filament_id - 1);

src/libslic3r/PerimeterGenerator.hpp

@@ -164,6 +164,8 @@ public:
     Polygons    lower_slices_polygons() const { return m_lower_slices_polygons; }
     // ORCA: the slices less the slivers the wall generator prints nothing for, so they never count as support.
     ExPolygons  printable_slices(const ExPolygons &slices) const;
+    // ORCA: whether this layer prints its outer walls first for the brim, see brim_puts_outer_walls_first().
+    bool        outer_walls_first_for_brim() const;
 
 private:
     std::vector<Polygons>     generate_lower_polygons_series(float width);
@@ -183,6 +185,10 @@ private:
     Polygons    m_lower_slices_polygons;
 };
 
+// ORCA: a brim against the outer walls makes the first layer print them first, whatever the wall sequence, so the
+// brim runs straight on into the outer wall. Auto, ear and painted brims may leave the outer walls bare.
+bool brim_puts_outer_walls_first(BrimType brim_type, double brim_width);
+
 }
 
 #endif

src/libslic3r/Preset.cpp

@@ -2293,6 +2293,7 @@ void PresetCollection::load_project_embedded_presets(std::vector<Preset*>& proje
                 BOOST_LOG_TRIVIAL(error) << boost::format("can not find parent for config %1%!")%preset->file;
                 continue;
             }
+            extend_default_config_length(config, false, {});
             preset->config.update_diff_values_to_child_config(config, extruder_id_name, extruder_variant_name, *key_set1, *key_set2);
             //preset->config.apply(std::move(config));
             Preset::normalize(preset->config);

src/libslic3r/PrintObject.cpp

@@ -17,6 +17,7 @@
 #include "I18N.hpp"
 #include "Layer.hpp"
 #include "MutablePolygon.hpp"
+#include "PerimeterGenerator.hpp"
 #include "PrintBase.hpp"
 #include "PrintConfig.hpp"
 #include "SLA/IndexedMesh.hpp"
@@ -1464,15 +1465,13 @@ bool PrintObject::invalidate_state_by_config_options(
             || opt_key == "top_surface_speed") {
             // Brim is printed below supports, support invalidates brim and skirt.
             steps.emplace_back(posSupportMaterial);
-            if (opt_key == "brim_type") {
+            if (opt_key == "brim_type" || opt_key == "brim_width") {
-                const auto* old_brim_type = old_config.option<ConfigOptionEnum<BrimType>>(opt_key);
+                // Regenerate the walls when the brim starts or stops putting the first layer's outer walls first.
-                const auto* new_brim_type = new_config.option<ConfigOptionEnum<BrimType>>(opt_key);
+                auto outer_walls_first = [](const ConfigOptionResolver &config) {
-                //BBS: When switch to manual brim, the object must have brim, then re-generate perimeter
+                    return brim_puts_outer_walls_first(config.option<ConfigOptionEnum<BrimType>>("brim_type")->value,
-                //to make the wall order of first layer to be outer-first
+                                                       config.option<ConfigOptionFloat>("brim_width")->value);
-                // btLeadingEdgeOnly is printed as an outer brim (Brim.cpp, BeltBrim.cpp), so it
+                };
-                // takes part in the same first-layer wall order rule.
+                if (outer_walls_first(old_config) != outer_walls_first(new_config))
-                if (old_brim_type->value == btOuterOnly || new_brim_type->value == btOuterOnly ||
-                    old_brim_type->value == btLeadingEdgeOnly || new_brim_type->value == btLeadingEdgeOnly)
                     steps.emplace_back(posPerimeters);
             }
         } else if (

src/libslic3r/Support/SupportCommon.cpp

@@ -707,8 +707,10 @@ void tree_supports_generate_paths(
                                             false);
         }
         if (eec) {
-            std::reverse(eec->entities.begin(), eec->entities.end());
+            if (!eec->empty()) {
-            dst.emplace_back(eec.release());
+                std::reverse(eec->entities.begin(), eec->entities.end());
+                dst.emplace_back(eec.release());
+            }
         }
     }
 }
@@ -1825,12 +1827,7 @@ void generate_support_toolpaths(
                     no_sort = true;
                 } else if (support_params.support_style == SupportMaterialStyle::smsTreeOrganic &&
                            (config.support_base_pattern == smpNone || config.support_base_pattern == smpDefault)) {
-                    // Orca: A special case for the hollow Organic supports
+                    tree_supports_generate_paths(base_layer.extrusions, base_layer.polygons_to_extrude(), flow, support_params);
-                    // Orca: If the tree supports are too tall, use a double wall to make it stronger
-                    SupportParameters support_params2 = support_params;
-                    if (support_layer.print_z > 100.0)
-                        support_params2.tree_branch_diameter_double_wall_area_scaled = 0.1;
-                    tree_supports_generate_paths(base_layer.extrusions, base_layer.polygons_to_extrude(), flow, support_params2);
                     done = true;
                 }
                 if (! done)

src/libslic3r/Support/TreeSupport.cpp

@@ -2149,7 +2149,9 @@ void TreeSupport::draw_circles()
     const bool with_lightning_infill = m_support_params.base_fill_pattern == ipLightning;
     coordf_t support_extrusion_width = m_support_params.support_extrusion_width;
     const float tree_brim_width = config.tree_support_brim_width.value;
-
+    // Reinforce branches moving more than half a support-line width between layers.
+    // Square the threshold for comparison with the squared XY movement below.
+    const double max_move_sq = sqr(double(scale_(m_object_config->support_line_width / 2)));
     // Belt floor: the first object layer is not on a flat bed — it rests on the
     // tilted, moving belt. So the first-object-layer adhesion features (the tree
     // support brim, the hybrid first-layer base expansion) must be suppressed:
@@ -2201,7 +2203,7 @@ void TreeSupport::draw_circles()
                 size_t           first_base_roof_area = 0;
                 bool             floor_interface_as_base = false;
                 bool has_circle_node = false;
-                bool need_extra_wall = false;
+                ExPolygons extra_wall_areas;
                 ExPolygons collision_sharp_tails;
                 ExPolygons collision_base;
                 auto             get_collision = [&](bool sharp_tail) -> ExPolygons             &{
@@ -2279,7 +2281,6 @@ void TreeSupport::draw_circles()
                         // area = diff_clipped({ ExPolygon(circle) }, get_collision(node.is_sharp_tail && node.distance_to_top <= 0));
 
                         if (!area.empty()) has_circle_node = true;
-                        if (node.need_extra_wall) need_extra_wall = true;
 
                         // merge overhang to get a smoother interface surface
                         // Do not merge when buildplate_only is on, because some underneath nodes may have been deleted.
@@ -2294,6 +2295,10 @@ void TreeSupport::draw_circles()
                         }
                     }
 
+                    // Use the Pythagorean theorem to compare movement magnitude (dx² + dy²) without a square root.
+                    if (node.is_processed && node.movement.cast<double>().squaredNorm() > max_move_sq)
+                        append(extra_wall_areas, area);
+
                     if (obj_layer_nr>0 && node.distance_to_top < 0)
                         append(roof_gap_areas, area);
                     else if (obj_layer_nr > 0 && node.support_roof_layers_below == 1 &&
@@ -2530,7 +2535,8 @@ void TreeSupport::draw_circles()
                     //if (area(expoly) < SQ(scale_(1))) continue;
                     area_groups.emplace_back(&expoly, SupportLayer::BaseType, max_layers_above_base);
                     area_groups.back().need_infill = overlaps({ expoly }, area_poly);
-                    area_groups.back().need_extra_wall = need_extra_wall && !area_groups.back().need_infill;
+                    area_groups.back().need_extra_wall = !area_groups.back().need_infill &&
+                        !extra_wall_areas.empty() && overlaps({expoly}, extra_wall_areas);
                 }
                 for (size_t roof_idx = 0; roof_idx < ts_layer->roof_areas.size(); ++roof_idx) {
                     auto &expoly = ts_layer->roof_areas[roof_idx];
@@ -3433,11 +3439,6 @@ void TreeSupport::smooth_nodes()
         }
     }
     
-    float max_move = scale_(m_object_config->support_line_width / 2);
-    // if the branch is very tall, the tip also needs extra wall
-    float thresh_tall_branch = 100;
-    float thresh_dist_to_top = 30;
-
     for (int layer_nr = 0; layer_nr< contact_nodes.size(); layer_nr++) {
         std::vector<SupportNode *> &curr_layer_nodes = contact_nodes[layer_nr];
         if (curr_layer_nodes.empty()) continue;
@@ -3447,20 +3448,17 @@ void TreeSupport::smooth_nodes()
                 std::vector<double> radii;
                 std::vector<SupportNode *>   branch;
                 SupportNode *              p_node = node;
-                float                        total_height = 0;
                 // add a fixed head if it's not a polygon node, see STUDIO-4403
                 // Polygon node can't be added because the move distance might be huge, making the nodes in between jump and dangling
                 if (node->child && node->child->type!=ePolygon) {
                     pts.push_back(p_node->child->position);
                     radii.push_back(p_node->child->radius);
                     branch.push_back(p_node->child);
-                    total_height += p_node->child->height;
                 }
                 do {
                     pts.push_back(p_node->position);
                     radii.push_back(p_node->radius);
                     branch.push_back(p_node);
-                    total_height += p_node->height;
                     p_node = p_node->parent;
                 } while (p_node && !p_node->is_processed);
                 if (pts.size() < 3) continue;
@@ -3479,9 +3477,6 @@ void TreeSupport::smooth_nodes()
                             branch[i]->radius = radii1[i];
                             branch[i]->movement = (pts[i + 1] - pts[i - 1]) / 2;
                             branch[i]->is_processed = true;
-                            if (branch[i]->parents.size() > 1 || (branch[i]->movement.x() > max_move || branch[i]->movement.y() > max_move) ||
-                                (total_height > thresh_tall_branch && branch[i]->dist_mm_to_top < thresh_dist_to_top))
-                                branch[i]->need_extra_wall = true;
                             BOOST_LOG_TRIVIAL(info) << "smooth_nodes: layer_nr=" << layer_nr << ", i=" << i << ", pt=" << pt << ", movement=" << branch[i]->movement << ", radius=" << branch[i]->radius;
                         }
                     }
@@ -3489,13 +3484,6 @@ void TreeSupport::smooth_nodes()
                         std::swap(pts, pts1);
                         std::swap(radii, radii1);
                     }
-                    else {
-                        // interpolate need_extra_wall in the end
-                        for (size_t i = 1; i < branch.size() - 1; i++) {
-                            if (branch[i - 1]->need_extra_wall && branch[i + 1]->need_extra_wall)
-                                branch[i]->need_extra_wall = true;
-                        }
-                    }
                 }
             }
         }

src/libslic3r/Support/TreeSupport.hpp

@@ -135,7 +135,6 @@ struct SupportNode
     TreeNodeType   type            = eCircle;
     bool           is_corner       = false;
     bool           is_processed    = false;
-    bool           need_extra_wall = false;
     bool           is_sharp_tail   = false;
     bool           valid = true;
     ExPolygon      overhang; // when type==ePolygon, set this value to get original overhang area

src/libvgcode/src/Layers.cpp

@@ -75,7 +75,7 @@ std::vector<float> Layers::get_zs() const
 
 size_t Layers::get_layer_id_at(float z) const
 {
-    auto iter = std::upper_bound(m_items.begin(), m_items.end(), z, [](float z, const Item& item) { return item.z < z; });
+    auto iter = std::upper_bound(m_items.begin(), m_items.end(), z, [](float z, const Item& item) { return item.z > z; });
     return std::distance(m_items.begin(), iter);
 }
 

src/slic3r/GUI/ConnectPrinter.cpp

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

src/slic3r/GUI/DeviceManager.cpp

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

src/slic3r/GUI/GUI_App.cpp

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

src/slic3r/GUI/ImGuiWrapper.cpp

@@ -62,6 +62,7 @@
 #include "Search.hpp"
 #include "BitmapCache.hpp"
 #include "GUI_App.hpp"
+#include "KeyChord.hpp"
 
 #include <nanosvg/nanosvg.h>
 #include <nanosvg/nanosvgrast.h>
@@ -2134,6 +2135,27 @@ bool ImGuiWrapper::want_any_input() const
     return io.WantCaptureMouse || io.WantCaptureKeyboard || io.WantTextInput;
 }
 
+bool ImGuiWrapper::text_input_active() const
+{
+    const ImGuiID id = ImGui::GetActiveID();
+    return id != 0 && ImGui::GetInputTextState(id) != nullptr;
+}
+
+bool ImGuiWrapper::modal_popup_open() const
+{
+    // A modal stays on the popup stack while its canvas is hidden, so it counts only if the last finished
+    // frame drew it, which NewFrame() moves from Active to WasActive.
+    const ImGuiWindow* modal = ImGui::GetTopMostPopupModal();
+    if (modal == nullptr)
+        return false;
+    return ImGui::GetCurrentContext()->WithinFrameScope ? modal->WasActive : modal->Active;
+}
+
+bool ImGuiWrapper::owns_key(const KeyChord& chord) const
+{
+    return modal_popup_open() || (chord.edits_text() && text_input_active());
+}
+
 ImFontAtlasCustomRect* ImGuiWrapper::GetTextureCustomRect(const wchar_t& tex_id)
 {
     auto item = m_custom_glyph_rects_ids.find(tex_id);

src/slic3r/GUI/ImGuiWrapper.hpp

@@ -35,6 +35,7 @@ struct ImRect;
 namespace Slic3r {
 namespace GUI {
 
+struct KeyChord;
 
 bool get_data_from_svg(const std::string &filename, unsigned int max_size_px, ThumbnailData &thumbnail_data);
 
@@ -219,6 +220,12 @@ public:
     bool want_keyboard() const;
     bool want_text_input() const;
     bool want_any_input() const;
+    // True while an ImGui InputText is active, without the one-frame lag of want_text_input().
+    bool text_input_active() const;
+    // True while an ImGui modal popup is on screen.
+    bool modal_popup_open() const;
+    // True for every key while a modal is open, and for text-editing keys while an InputText is active.
+    bool owns_key(const KeyChord& chord) const;
 
     // Optional inputs are used for set up value inside of an optional, with default value
     // 

src/slic3r/GUI/KBShortcutsDialog.cpp

@@ -173,7 +173,7 @@ void KBShortcutsDialog::fill_pages()
     using Section              = ShortcutSection;
 
     if (wxGetApp().is_editor()) {
-        page(_L("Global"), _L("Available anywhere in the window, even while typing in a text field."), ShortcutContext::Global, {
+        page(_L("Global"), _L("Available anywhere in the window."), ShortcutContext::Global, {
             fixed(Section::SpeedDial, { alt, "1-9, 0" }, L("Run favorite 1 to 10")),
             fixed(Section::SpeedDial, { ctrl, "B" }, L("Pin or unpin the selected action")),
             // wx cycles notebook pages on Ctrl+Tab, which is Cmd+Tab on macOS and never arrives there.
@@ -438,17 +438,16 @@ ShortcutCaptureDialog::ShortcutCaptureDialog(wxWindow* parent, Shortcut shortcut
     SetBackgroundColour(*wxWHITE);
     wxBoxSizer* sizer = new wxBoxSizer(wxVERTICAL);
 
-    // A Global shortcut also runs while a text field has the focus, so its hint names the keys it can use.
+    // A Global shortcut runs before the focused control gets the key, so its hint names the keys it can use.
     const bool     global = (shortcut_info(shortcut).contexts & context_bit(ShortcutContext::Global)) != 0;
     const wxString advice = global_key_advice();
-    const wxString typing = _L("Global shortcuts also apply while typing.");
     const wxString rule   = _L("A key that types a character cannot be a global shortcut.");
-    m_hint      = global ? typing + "\n" + advice : _L("Esc cancels, Enter confirms.");
+    m_hint      = global ? advice : _L("Esc cancels, Enter confirms.");
     m_rejection = rule + "\n" + advice;
 
     // Wide enough for each sentence on a line of its own where the translation allows, within limits.
     int width = FromDIP(450);
-    for (const wxString& sentence : { typing, rule, advice }) {
+    for (const wxString& sentence : { rule, advice }) {
         int extent = 0;
         GetTextExtent(sentence, &extent, nullptr, nullptr, nullptr, &wxGetApp().normal_font());
         width = std::max(width, extent);

src/slic3r/GUI/KeyChord.cpp

@@ -187,6 +187,40 @@ bool KeyChord::is_menu_accelerator() const
     return valid() && ((modifiers & (wxMOD_CONTROL | wxMOD_ALT | wxMOD_RAW_CONTROL)) != 0 || (!is_printable(key) && key != WXK_SPACE));
 }
 
+bool KeyChord::edits_text() const
+{
+    if (!valid())
+        return false;
+    if (!is_menu_accelerator())
+        return true;
+    const int mods = modifiers & ~wxMOD_SHIFT;
+    switch (key) {
+    case WXK_LEFT: case WXK_RIGHT: case WXK_UP: case WXK_DOWN:
+    case WXK_HOME: case WXK_END: case WXK_BACK: case WXK_DELETE:
+#ifdef __APPLE__
+        return mods == wxMOD_NONE || mods == wxMOD_CONTROL || mods == wxMOD_ALT; // Option moves by word
+#else
+        return mods == wxMOD_NONE || mods == wxMOD_CONTROL;
+#endif
+    case WXK_INSERT:
+        return mods == wxMOD_NONE || mods == wxMOD_CONTROL;
+    case WXK_RETURN: case WXK_TAB: case WXK_ESCAPE: case WXK_PAGEUP: case WXK_PAGEDOWN:
+        return mods == wxMOD_NONE;
+    default:
+        break;
+    }
+    if (!is_printable(key))
+        return false;
+#ifdef __APPLE__
+    if (mods == wxMOD_ALT || mods == wxMOD_RAW_CONTROL)
+        return true; // Option types a character, Control runs the Cocoa text key bindings
+#else
+    if (mods == (wxMOD_CONTROL | wxMOD_ALT))
+        return true; // AltGr types a character
+#endif
+    return mods == wxMOD_CONTROL && (key == 'A' || key == 'C' || key == 'V' || key == 'X' || key == 'Y' || key == 'Z');
+}
+
 // Only a chord the desktop acts on while still delivering it to the app belongs here.
 bool KeyChord::is_system_shortcut() const
 {

src/slic3r/GUI/KeyChord.hpp

@@ -35,6 +35,9 @@ struct KeyChord
     // True when Ctrl or Alt is held or the key is non-printable, the chords a menu can own without
     // swallowing typing in text fields.
     bool is_menu_accelerator() const;
+    // True for a chord a focused text field acts on: typing a character (AltGr and macOS Option
+    // characters included), moving the caret, selecting, deleting, or the clipboard and undo chords.
+    bool edits_text() const;
     // True for a chord the desktop acts on although the app receives it, so a binding would
     // take it from the system.
     bool is_system_shortcut() const;

src/slic3r/GUI/MainFrame.cpp

@@ -50,6 +50,7 @@
 #include <wx/panel.h>
 #include <wx/settings.h>
 #include <wx/textentry.h>
+#include <wx/spinctrl.h>
 #include <wx/notebook.h>
 #include <wx/listbook.h>
 #include <wx/simplebook.h>
@@ -107,6 +108,8 @@
 #include "../Utils/PrintHost.hpp"
 
 #include "GUI_App.hpp"
+#include "ImGuiWrapper.hpp"
+#include "OpenGLManager.hpp"
 #include "Shortcuts.hpp"
 #include "UnsavedChangesDialog.hpp"
 #include "PublishSettingsDialog.hpp"
@@ -184,18 +187,31 @@ enum class ERescaleTarget
 
 namespace {
 
+bool focus_is_text_field(wxWindow* focus)
+{
+    if (dynamic_cast<wxTextEntryBase*>(focus) || dynamic_cast<wxWebView*>(focus))
+        return true; // a web page can have its own text fields
+    if (dynamic_cast<wxSpinCtrl*>(focus) || dynamic_cast<wxSpinCtrlDouble*>(focus))
+        return true; // the native Windows spin control is not a wxTextEntry
+    return false;
+}
+
+// Only a scene canvas draws ImGui, and a hidden one can keep the wx focus after a tab switch.
+const ImGuiWrapper* focused_canvas_imgui(wxWindow* focus)
+{
+    if (!OpenGLManager::is_scene_canvas(focus) || !focus->IsShownOnScreen())
+        return nullptr;
+    return wxGetApp().imgui();
+}
+
 // Space opens the speed dial, but it is the activation key for buttons, checkboxes and other
-// controls. CHAR_HOOK runs before the focused child, so only take Space when the focused window has
+// controls, so only take Space when the focused window has no keyboard-activation meaning of its
-// no keyboard-activation meaning of its own. Canvases (GLCanvas3D) and panels are not controls and
+// own. Canvases (GLCanvas3D) and panels are not controls and fall through to "open"; the Notebook
-// fall through to "open"; the Notebook itself does too, so Space still opens the dial on any page.
+// itself does too, so Space still opens the dial on any page.
 bool focus_keeps_space(wxWindow* focus)
 {
     if (!focus)
         return false;
-    if (dynamic_cast<wxTextEntryBase*>(focus))
-        return true; // typing a space into a text field
-    if (dynamic_cast<wxWebView*>(focus))
-        return true; // web content scrolls and hosts its own text fields
     if (dynamic_cast<::Button*>(focus))
         return true; // custom button: Space clicks it (it is a wxWindow, not a wxControl)
     if (dynamic_cast<StaticBox*>(focus))
@@ -816,16 +832,12 @@ DPIFrame(NULL, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, BORDERLESS_FRAME_
 
 bool MainFrame::handle_global_shortcut(const KeyChord& chord)
 {
-    // ImGui draws its text fields (the text tool's box, a sketch value field) on the GL canvas, so
+    // CHAR_HOOK runs before the focused window, so leave text-editing keys to a focused text field and
-    // while one of them is typed into the focused wx window is that canvas or an in-canvas frame:
+    // the keys ImGui owns to the focused canvas.
-    // neither is a wxControl, so focus_keeps_space() cannot see it and CHAR_HOOK takes the chord
-    // here first -- Space opened the Speed Dial, Ctrl+P the Preferences, and the field never saw
-    // the key. ImGui raises WantCaptureKeyboard while one of its items owns the keyboard, so leave
-    // the key to it then. A focused wxControl (text field, list, web view) is untouched: those
-    // keep their own keys, and ImGui's flag can outlive the focus moving to one of them.
     wxWindow* const focus = wxWindow::FindFocus();
-    ImGuiWrapper* const imgui = wxGetApp().imgui();
+    if (chord.edits_text() && focus_is_text_field(focus))
-    if (focus != nullptr && imgui != nullptr && imgui->want_keyboard() && dynamic_cast<wxControl*>(focus) == nullptr)
+        return false;
+    if (const ImGuiWrapper* imgui = focused_canvas_imgui(focus); imgui != nullptr && imgui->owns_key(chord))
         return false;
 
     const std::optional<Shortcut> shortcut = wxGetApp().shortcuts().lookup(ShortcutContext::Global, chord);

src/slic3r/GUI/OpenGLManager.cpp

@@ -427,6 +427,8 @@ wxGLContext* OpenGLManager::init_glcontext(wxGLCanvas& canvas, const std::pair<i
     return m_context;
 }
 
+static const char* const SCENE_CANVAS_NAME = "OrcaSceneCanvas";
+
 wxGLCanvas* OpenGLManager::create_wxglcanvas(wxWindow& parent)
 {
     int antialiasing_samples = 4;
@@ -470,12 +472,17 @@ wxGLCanvas* OpenGLManager::create_wxglcanvas(wxWindow& parent)
         attribList[samples_value_idx] = 0;
     }
 
-    wxGLCanvas* canvas = new wxGLCanvas(&parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS);
+    wxGLCanvas* canvas = new wxGLCanvas(&parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize, wxWANTS_CHARS, SCENE_CANVAS_NAME);
     // The GL canvas paints its entire surface, so background erasing is unnecessary.
     canvas->SetBackgroundStyle(wxBG_STYLE_PAINT);
     return canvas;
 }
 
+bool OpenGLManager::is_scene_canvas(const wxWindow* window)
+{
+    return window != nullptr && window->GetName() == SCENE_CANVAS_NAME;
+}
+
 void OpenGLManager::detect_multisample(int* attribList)
 {
     int wxVersion = wxMAJOR_VERSION * 10000 + wxMINOR_VERSION * 100 + wxRELEASE_NUMBER;

src/slic3r/GUI/OpenGLManager.hpp

@@ -101,6 +101,8 @@ public:
     static bool are_framebuffers_supported() { return (s_framebuffers_type != EFramebufferType::Unknown); }
     static EFramebufferType get_framebuffers_type() { return s_framebuffers_type; }
     static wxGLCanvas* create_wxglcanvas(wxWindow& parent);
+    // True for a canvas made by create_wxglcanvas(), the kind a GLCanvas3D draws its scene and ImGui into.
+    static bool is_scene_canvas(const wxWindow* window);
     static const GLInfo& get_gl_info() { return s_gl_info; }
     static bool force_power_of_two_textures() { return s_force_power_of_two_textures; }
 

src/slic3r/GUI/Plater.cpp

@@ -21178,7 +21178,12 @@ void Plater::print_job_finished(wxCommandEvent &evt)
     Slic3r::DeviceManager* dev = Slic3r::GUI::wxGetApp().getDeviceManager();
     if (!dev) return;
 
-    dev->set_selected_machine(evt.GetString().ToStdString());
+    const std::string dev_id = evt.GetString().ToStdString();
+    MachineObject* selected = dev->get_selected_machine();
+    // After a LAN print, the completion event reselects the same printer.
+    // Keep the active session while asynchronous status traffic may still be in flight.
+    if (!selected || selected->get_dev_id() != dev_id || selected->connection_type() != "lan")
+        dev->set_selected_machine(dev_id);
     p->main_frame->request_select_tab(TAB_ID_MONITOR);
     // Selects the status page on a built Device tab; one built by the switch starts there.
     MonitorPanel* curr_monitor = MonitorPanel::if_built();

src/slic3r/GUI/ReleaseNote.cpp

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

src/slic3r/GUI/Selection.cpp

@@ -474,17 +474,14 @@ void Selection::add_curr_plate()
     if (!m_valid)
         return;
 
+    std::vector<unsigned int> volume_idxs = get_volume_idxs_from_plate(wxGetApp().plater()->get_partplate_list().get_curr_plate_index());
+    if (volume_idxs.empty())
+        return;
+
     wxGetApp().plater()->take_snapshot(std::string("Selection-Add Curr Plate All!"));
     m_mode = Instance;
     clear();
-
+    do_add_volumes(volume_idxs);
-    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
-    for (int obj_idx = 0; obj_idx < m_model->objects.size(); obj_idx++) {
-        if (plate && plate->contain_instance_totally(obj_idx, 0)) {
-            std::vector<unsigned int> volume_idxs = get_volume_idxs_from_object(obj_idx);
-            do_add_volumes(volume_idxs);
-        }
-    }
 
     update_type();
     this->set_bounding_boxes_dirty();
@@ -511,20 +508,14 @@ void Selection::remove_curr_plate()
     if (!m_valid)
         return;
 
-    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_curr_plate();
+    std::vector<unsigned int> volume_idxs = get_volume_idxs_from_plate(wxGetApp().plater()->get_partplate_list().get_curr_plate_index());
-    if (plate->empty())
+    if (volume_idxs.empty())
         return;
 
     wxGetApp().plater()->take_snapshot(std::string("Selection-Delete Curr Plate All"));
     m_mode = Instance;
     clear();
-
+    do_add_volumes(volume_idxs);
-    for (int obj_idx = 0; obj_idx < m_model->objects.size(); obj_idx++) {
-        if (plate && plate->contain_instance(obj_idx, 0)) {
-            std::vector<unsigned int> volume_idxs = get_volume_idxs_from_object(obj_idx);
-            do_add_volumes(volume_idxs);
-        }
-    }
 
     update_type();
     this->set_bounding_boxes_dirty();
@@ -2270,6 +2261,27 @@ std::vector<unsigned int> Selection::get_volume_idxs_from_volume(unsigned int ob
     return idxs;
 }
 
+std::vector<unsigned int> Selection::get_volume_idxs_from_plate(const int plate_idx) const
+{
+    PartPlate* plate = wxGetApp().plater()->get_partplate_list().get_plate(plate_idx);
+    std::vector<unsigned int> idxs;
+    if (!plate)
+        return idxs;
+
+    for (int obj_idx = 0; obj_idx < (int)m_model->objects.size(); obj_idx++) {
+        const ModelObject* obj = m_model->objects[obj_idx];
+        for (int inst_idx = 0; inst_idx < (int)obj->instances.size(); inst_idx++) {
+            // on this plate or overlapping it in some way (fully inside, oversized or partly outside)
+            if (plate->contain_instance(obj_idx, inst_idx) || plate->intersect_instance(obj_idx, inst_idx)) {
+                std::vector<unsigned int> inst_idxs = get_volume_idxs_from_instance(obj_idx, inst_idx);
+                idxs.insert(idxs.end(), inst_idxs.begin(), inst_idxs.end());
+            }
+        }
+    }
+
+    return idxs;
+}
+
 std::vector<unsigned int> Selection::get_missing_volume_idxs_from(const std::vector<unsigned int>& volume_idxs) const
 {
     std::vector<unsigned int> idxs;

src/slic3r/GUI/Selection.hpp

@@ -409,6 +409,8 @@ public:
     std::vector<unsigned int> get_volume_idxs_from_instance(unsigned int object_idx, unsigned int instance_idx) const;
     // returns the idx of the volume corresponding to the volume with the given idxs
     std::vector<unsigned int> get_volume_idxs_from_volume(unsigned int object_idx, unsigned int instance_idx, unsigned int volume_idx) const;
+    // returns the list of idxs of the volumes of all instances on the given plate or overlapping it. (fully inside, oversized or partly outside)
+    std::vector<unsigned int> get_volume_idxs_from_plate(const int plate_idx) const;
     // returns the list of idxs of the volumes contained in the selection but not in the given list
     std::vector<unsigned int> get_missing_volume_idxs_from(const std::vector<unsigned int>& volume_idxs) const;
     // returns the list of idxs of the volumes contained in the given list but not in the selection

src/slic3r/GUI/TroubleshootDialog.cpp

@@ -74,6 +74,7 @@
 #endif
 
 #ifdef __LINUX__
+#include "LinuxDisplayBackend.hpp"
 #include <wx/textfile.h>
 #include <wx/tokenzr.h>
 #include <cstdlib>
@@ -201,7 +202,11 @@ TroubleshootDialog::TroubleshootDialog()
             return std::vector<wxString>{GetOStype()};
         return std::vector<wxString>{
             GetOSinfo(),
+#ifdef __LINUX__
+            GetPackageType() + GetAppDisplayBackend(),
+#else
             GetPackageType(),
+#endif
             GetCPUinfo(),
             GetRAMinfo() + " RAM",
             GetGPUinfo(),
@@ -434,10 +439,15 @@ wxString TroubleshootDialog::GetTimestamp()
 
 wxString TroubleshootDialog::GetSysInfoAll()
 {
+    wxString package = GetPackageType();
+#ifdef __LINUX__
+    package += GetAppDisplayBackend();
+#endif
+
     wxString info;
     info += "Version   :  " + wxString(SoftFever_VERSION) + "\n"
           + "Build     :  " + wxString(build_commit_label) + "\n"
-          + "Package   :  " + GetPackageType() + "\n"
+          + "Package   :  " + package + "\n"
           + "Platform  :  " + GetOSinfo()      + "\n"
           + "Processor :  " + GetCPUinfo() + "\n"
           + "Memory    :  " + GetRAMinfo() + "RAM" + "\n"
@@ -751,6 +761,18 @@ wxString TroubleshootDialog::GetLinuxDisplayServer()
 
     return "";
 }
+
+wxString TroubleshootDialog::GetAppDisplayBackend()
+{
+    // Display backend actually used by the app (GDK), not the session type
+    wxString display;
+    switch (get_linux_display_backend()) {
+        case LinuxDisplayBackend::X11:     display = "X11";     break;
+        case LinuxDisplayBackend::Wayland: display = "Wayland"; break;
+        default: break;
+    }
+    return display.IsEmpty() ? "" : (" (" + display + ")"); // spacing included here to prevent non centered text
+}
 #endif
 
 wxString TroubleshootDialog::GetPackageType()

src/slic3r/GUI/TroubleshootDialog.hpp

@@ -68,6 +68,7 @@ protected:
 #elif defined(__LINUX__)
     wxString GetLinuxDistroName();
     wxString GetLinuxDisplayServer();
+    wxString GetAppDisplayBackend();
 #endif
     wxString GetPackageType();
     wxString GetCPUinfo();

src/slic3r/Utils/BBLPrinterAgent.cpp

@@ -204,8 +204,9 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
         int dir = input_val > 0 ? 1 : -1;
         // i3-arch printers move the bed for Y/Z, so the on-screen direction is
         // reversed -- same negation the g-code fallback below applies.
-        if (!is_core_xy && (axis == "Y" || axis == "Z"))
+        if (!is_core_xy && (axis == "Y" || axis == "Z")) {
             dir = -dir;
+        }
 
         j["print"]["command"] = "xyz_ctrl";
         j["print"]["axis"] = axis;
@@ -215,8 +216,9 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
     }
 
     double value = input_val;
-    if (!is_core_xy && (axis == "Y" || axis == "Z"))
+    if (!is_core_xy && (axis == "Y" || axis == "Z")) {
-        value = -input_val;
+        value = -1.0 * input_val;
+    }
 
     std::string value_str = (boost::format("%.1f") % (value * unit)).str();
     std::string gcode;
@@ -237,10 +239,11 @@ int BBLPrinterAgent::command_axis_control(std::string dev_id, std::string axis,
 int BBLPrinterAgent::publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode)
 {
     const int rtn = lan_mode ? send_message_to_printer(dev_id, j.dump(), 0, 0) : send_message(dev_id, j.dump(), 0, 0);
-    if (rtn == 0)
+    if (rtn == 0) {
         BOOST_LOG_TRIVIAL(info) << "publish_json: " << j.dump() << " code: " << rtn;
-    else
+    } else {
         BOOST_LOG_TRIVIAL(error) << "publish_json: " << j.dump() << " code: " << rtn;
+    }
     return rtn;
 }
 
@@ -586,8 +589,21 @@ int BBLPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateS
 
 int BBLPrinterAgent::start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
 {
-    return dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
+    // dispatch_start() moves out of `params`, so snapshot the diagnostic fields first;
+    // logging them after the call would print empty strings.
+    const bool        try_emmc_print = params.try_emmc_print;
+    const std::string dev_ip         = params.dev_ip;
+    const std::string dev_id         = params.dev_id;
+
+    int result = dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
         BBLNetworkPlugin::instance().get_start_send_gcode_to_sdcard(), params, update_fn, cancel_fn, wait_fn);
+    if (result != 0) {
+        BOOST_LOG_TRIVIAL(error) << "start_send_gcode_to_sdcard failed: result=" << result
+            << ", try_emmc_print=" << try_emmc_print
+            << ", legacy_mode=" << BBLNetworkPlugin::instance().use_legacy_network()
+            << ", dev_ip=" << dev_ip << ", dev_id=" << dev_id;
+    }
+    return result;
 }
 
 int BBLPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)

src/slic3r/Utils/BBLPrinterAgent.hpp

@@ -110,6 +110,7 @@ public:
     static std::string from_orca_payload(std::string json_text);
 
 private:
+    // why: the lan/cloud DECISION stays machine-side; keep this mechanical branch in sync with publish_json.
     int publish(const std::string& dev_id, const nlohmann::json& j, bool lan_mode);
 };
 

src/slic3r/Utils/CrealityPrintAgent.cpp

@@ -288,22 +288,27 @@ bool CrealityPrintAgent::parse_cfs_response(const std::string&    response,
     return true;
 }
 
-bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
+bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
 {
-    if (device_info.dev_ip.empty()) {
+    if (sync_mode != get_filament_sync_mode())
+        return false;
+
+    const MoonrakerDeviceInfo info = snapshot_device_info();
+
+    if (info.dev_ip.empty()) {
         BOOST_LOG_TRIVIAL(warning)
             << "CrealityPrintAgent::fetch_filament_info: no device IP, falling back to base agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
     }
 
     // Build a CrealityPrint helper so we can use its model detection + WS helpers
     // (added in upstream PR #13291).
     DynamicPrintConfig cfg;
-    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + device_info.dev_ip));
+    cfg.set_key_value("print_host",                  new ConfigOptionString("http://" + info.dev_ip));
     cfg.set_key_value("print_host_webui",            new ConfigOptionString(""));
     cfg.set_key_value("printhost_cafile",            new ConfigOptionString(""));
     cfg.set_key_value("printhost_port",              new ConfigOptionString(""));
-    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(device_info.api_key));
+    cfg.set_key_value("printhost_apikey",            new ConfigOptionString(info.api_key));
     cfg.set_key_value("printhost_ssl_ignore_revoke", new ConfigOptionBool(false));
 
     CrealityPrint host(&cfg);
@@ -313,7 +318,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         BOOST_LOG_TRIVIAL(info)
             << "CrealityPrintAgent: " << host.model_name()
             << " is not CFS-capable, deferring to base Moonraker agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
     }
 
     BOOST_LOG_TRIVIAL(info)
@@ -328,7 +333,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         BOOST_LOG_TRIVIAL(warning)
             << "CrealityPrintAgent: CFS query failed (" << parse_err << "), "
             << "falling back to base agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
     }
 
     if (box_count == 0) {
@@ -337,7 +342,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         // Moonraker exposes.
         BOOST_LOG_TRIVIAL(info)
             << "CrealityPrintAgent: no active CFS boxes, deferring to base agent";
-        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id));
+        return MoonrakerPrinterAgent::fetch_filament_info(std::move(dev_id), sync_mode);
     }
 
     BOOST_LOG_TRIVIAL(info)
@@ -382,7 +387,7 @@ bool CrealityPrintAgent::fetch_filament_info(std::string dev_id, FilamentSyncMod
         }
     }
 
-    build_ams_payload(box_count, max_slots - 1, trays);
+    build_ams_payload(box_count, max_slots - 1, trays, sync_mode == FilamentSyncMode::pull);
     return true;
 }
 

src/slic3r/Utils/CrealityPrintAgent.hpp

@@ -37,12 +37,13 @@ public:
     };
 
     explicit CrealityPrintAgent(std::string log_dir);
-    ~CrealityPrintAgent() override = default;
+    ~CrealityPrintAgent() override { shutdown(); }
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
+    FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::pull; }
 
     // Parse the boxsInfo JSON returned by CrealityPrint::query_boxes_info() into
     // a flat list of loaded slots, plus the count of CFS boxes the printer reports.

src/slic3r/Utils/IPrinterAgent.hpp

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

src/slic3r/Utils/MoonrakerPrinterAgent.hpp

@@ -5,6 +5,7 @@
 #include "bambu_networking.hpp"
 
 #include <functional>
+#include <chrono>
 #include <cstdint>
 #include <atomic>
 #include <memory>
@@ -12,6 +13,8 @@
 #include <set>
 #include <string>
 #include <thread>
+#include <condition_variable>
+#include <deque>
 
 #include <nlohmann/json.hpp>
 #include <vector>
@@ -20,6 +23,56 @@ namespace Slic3r { class ICloudServiceAgent; }
 
 namespace Slic3r {
 
+class Http;
+
+bool moonraker_is_light_name(const std::string& name);
+// Direction encoded by a light name: +1 turns on, -1 turns off, 0 is an ambiguous toggle.
+// e.g. LIGHT_ON -> +1, LIGHT_OFF -> -1, LIGHT -> 0.
+int moonraker_light_name_direction(const std::string& name);
+
+struct MoonrakerWebcamSelection
+{
+    std::string      url;
+    CameraStreamMode mode = CameraStreamMode::none;
+    std::string      name;
+    std::string      error;  // set when no selectable webcam was found
+};
+
+// Selects a webcam from a parsed /server/webcams/list response (the top-level JSON or its
+// "result" value). Returns true and fills url/mode/name on success; on failure returns
+// false and sets error.
+bool moonraker_parse_webcam_list(const nlohmann::json& response, const std::string& base_url,
+                                 MoonrakerWebcamSelection& out);
+
+class MoonrakerWebsocket
+{
+public:
+    enum class ReadResult
+    {
+        message,
+        timeout,
+        closed,
+        error,
+    };
+
+    MoonrakerWebsocket(bool secure, std::string api_key, std::string ca_file);
+    ~MoonrakerWebsocket();
+
+    void connect(const std::string& host, const std::string& port, std::chrono::seconds timeout);
+    void tls_handshake(const std::string& host);
+    void handshake(const std::string& host, const std::string& target);
+    void text(bool enabled);
+    void write(const std::string& body);
+    ReadResult read(std::string& payload, std::string& error_message);
+    void close();
+    void expires_after(std::chrono::seconds timeout);
+    void abort();
+
+private:
+    struct Impl;
+    std::unique_ptr<Impl> m_impl;
+};
+
 class MoonrakerPrinterAgent : public IPrinterAgent
 {
 public:
@@ -65,12 +118,26 @@ public:
     int set_on_local_connect_fn(OnLocalConnectedFn fn) override;
     int set_on_local_message_fn(OnMessageFn fn) override;
     int set_queue_on_main_fn(QueueOnMainFn fn) override;
-
+    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
     // Pull-mode agent (on-demand filament sync)
     FilamentSyncMode get_filament_sync_mode() const override { return FilamentSyncMode::pull; }
-    bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
+    CameraStreamMode get_camera_stream_mode() const override;
+    std::string get_camera_url() const override;
+
+    // Called by the fetch-thread RAII guard when a background filament fetch finishes.
+    // Serialized with the reservation so shutdown()'s wait cannot miss the transition to 0.
+    void release_fetch_slot() noexcept;
 
 protected:
+    struct ConnectionSettings
+    {
+        std::string dev_id;
+        std::string base_url;
+        std::string api_key;
+        bool        use_ssl = false;
+        std::string ca_file;
+    };
+
     struct MoonrakerDeviceInfo
     {
         std::string dev_id;
@@ -82,9 +149,21 @@ protected:
         std::string dev_name;
         std::string version;
         std::string klippy_state;
+        float       nozzle_diameter = 0.0f;
         bool        use_ssl = false;
+        std::string ca_file;
     } device_info;
 
+    // Copied when the stream starts, so changes apply to the next start_status_stream()
+    struct StatusStreamTimings
+    {
+        std::chrono::milliseconds handshake{std::chrono::seconds(10)};      // Opening and closing handshakes
+        std::chrono::milliseconds close{std::chrono::seconds(1)};           // Wait for the close frame's answer before dropping the socket
+        std::chrono::milliseconds idle{std::chrono::seconds(30)};           // Silence before giving up, with a ping every half of it
+        std::chrono::milliseconds heartbeat{std::chrono::seconds(10)};      // Silence before the cached status is sent again
+        std::chrono::milliseconds reconnect_delay{std::chrono::seconds(1)}; // First wait, doubling per consecutive failure up to 32x
+    } ws_timings;
+
     // Tray data for AMS payload building
     struct AmsTrayData {
         int         slot_index = 0;      // 0-based slot index
@@ -96,16 +175,47 @@ protected:
         int         nozzle_temp = 0;     // Optional
     };
 
-    // Build ams JSON and call parser
+    // Build ams JSON and call parser.
-    void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays);
+    // apply_inline: when true the MachineObject mutation runs on the calling thread, which
+    // must therefore be the main thread; when false it is deferred through queue_on_main_fn.
+    // Pull-mode fetches run synchronously on the GUI thread and are read back immediately, so
+    // they pass true to avoid the deferred mutation landing after the caller's read.
+    //
+    // resolve_tray_ids: optional hook that runs as part of the commit, i.e. on the main thread.
+    // Agents that would otherwise resolve tray_info_idx against GUI-owned preset state on a
+    // background fetch thread must do it here to avoid racing the GUI. It must not capture
+    // `this` (the commit may outlive the agent).
+    using ResolveAmsTrayIdsFn = std::function<void(std::vector<AmsTrayData>&)>;
+    void build_ams_payload(int ams_count, int max_lane_index, const std::vector<AmsTrayData>& trays, bool apply_inline = false,
+                           ResolveAmsTrayIdsFn resolve_tray_ids = {});
 
     // Methods that derived classes may need to override or access
-    virtual bool init_device_info(const std::string& dev_id, const std::string& dev_ip, const std::string& username, const std::string& password, bool use_ssl, const std::string& port);
+    virtual bool init_device_info(const PrinterConnectionParams& params);
-    virtual bool fetch_device_info(const std::string& base_url, const std::string& api_key, MoonrakerDeviceInfo& info, std::string& error) const;
+    virtual bool fetch_device_info(const ConnectionSettings& connection, MoonrakerDeviceInfo& info, std::string& error) const;
+    ConnectionSettings get_connection_settings() const;
+    // Copy of the mutable connection state, taken under connect_mutex. Background threads
+    // must use this instead of reading device_info directly.
+    MoonrakerDeviceInfo snapshot_device_info() const;
+    void configure_http(Http& http, const ConnectionSettings& connection) const;
+    static float parse_nozzle_diameter(const nlohmann::json& response);
+    // The connection is copied when the stream starts, so changes apply to the next start.
+    void start_status_stream(const std::string& dev_id, ConnectionSettings connection);
+    void stop_status_stream();
 
     // State access for derived classes
     mutable std::recursive_mutex       state_mutex;
 
+    // Detached fetch threads hold a raw `this`; shutdown() waits for this to reach 0.
+    std::atomic<int> filament_fetch_in_flight{0};
+
+    // Idempotent teardown; must be called from the most-derived destructor.
+    void shutdown();
+    std::atomic<bool> shutting_down{false};
+
+    // Serializes the shutting_down check with the in-flight reservation.
+    std::mutex fetch_lifecycle_mutex;
+    std::condition_variable fetch_done_cv;  // notified when filament_fetch_in_flight reaches 0
+
     // Helpers
     bool        is_numeric(const std::string& value);
     std::string normalize_base_url(bool use_ssl, const std::string& host, const std::string& port);
@@ -118,13 +228,30 @@ protected:
     // Map filament type to OrcaFilamentLibrary preset ID for AMS sync compatibility
     static std::string map_filament_type_to_generic_id(const std::string& filament_type);
 
+    // Send a G-code script via Moonraker (/printer/gcode/script)
+    bool send_gcode(const std::string& dev_id, const std::string& gcode) const;
+    bool send_gcode(const std::string& dev_id, const std::string& gcode,
+                    const ConnectionSettings& connection) const;
+    bool post_print_action(const std::string& action) const;
+    bool post_print_action(const std::string& action,
+                           const ConnectionSettings& connection) const;
+
+    bool send_ws_rpc(const std::string& method, const nlohmann::json& params);
+
+    virtual void on_status_loop_tick(const std::string& dev_id) {}
+
+    // Queue work that may use agent state. The command worker is joined during
+    // destruction, so queued commands cannot outlive the agent.
+    void enqueue_command(std::function<void()> fn);
+    mutable std::recursive_mutex connect_mutex;
+
 private:
     int handle_request(const std::string& dev_id, const std::string& json_str);
     int send_version_info(const std::string& dev_id);
     int send_access_code(const std::string& dev_id);
 
-    bool fetch_object_list(const std::string& base_url, const std::string& api_key, std::set<std::string>& objects, std::string& error) const;
+    bool fetch_object_list(const ConnectionSettings& connection, std::set<std::string>& objects, std::string& error) const;
-    bool query_printer_status(const std::string& base_url, const std::string& api_key, nlohmann::json& status, std::string& error) const;
+    bool query_printer_status(const ConnectionSettings& connection, nlohmann::json& status, std::string& error) const;
     bool send_gcode_sync(const std::string& dev_id, const std::string& gcode) const;
     void send_gcode_async(const std::string& dev_id, const std::string& gcode,
                           std::function<void(bool)> on_result = {}) const;
@@ -132,37 +259,46 @@ private:
     void announce_printhost_device();
     void dispatch_local_connect(int state, const std::string& dev_id, const std::string& msg);
     void dispatch_printer_connected(const std::string& dev_id);
+
+    // Self-contained snapshot of the message callbacks. Async completions capture this
+    // by value so they never dereference `this` after the agent may have been destroyed.
+    struct MessageRouter
+    {
+        OnMessageFn   local_fn;
+        OnMessageFn   cloud_fn;
+        QueueOnMainFn queue_fn;
+        std::string   dev_id;
+
+        void deliver(std::string payload) const;
+    };
+
+    MessageRouter make_message_router(const std::string& dev_id) const;
     void dispatch_message(const std::string& dev_id, const std::string& payload);
-    void start_status_stream(const std::string& dev_id, const std::string& base_url, const std::string& api_key);
+    // Joins a stream stopped from its own callback, so a new stream can start without waiting on it under connect_mutex
-    void stop_status_stream();
+    void join_stopped_status_stream();
-    void run_status_stream(std::string dev_id, std::string base_url, std::string api_key);
+    void run_status_stream(std::string dev_id, ConnectionSettings connection, StatusStreamTimings timings);
-    void handle_ws_message(const std::string& dev_id, const std::string& payload);
+    void handle_ws_message(std::string dev_id, std::string payload, ConnectionSettings connection);
+    void send_heartbeat_if_due(const std::string& dev_id, std::chrono::milliseconds interval);
+    void refresh_thumbnail_url(const ConnectionSettings& connection);
     void update_status_cache(const nlohmann::json& updates);
     nlohmann::json build_print_payload_locked() const;
 
-    // Print control helpers
-    int pause_print(const std::string& dev_id);
-    int resume_print(const std::string& dev_id);
-    int cancel_print(const std::string& dev_id);
-
     // File upload
     bool upload_gcode(const std::string& local_path, const std::string& filename,
-                      const std::string& base_url, const std::string& api_key,
+                      const ConnectionSettings& connection,
                       OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
 
-    // JSON-RPC helper
-    bool send_jsonrpc_command(const std::string& base_url, const std::string& api_key,
-                              const nlohmann::json& request, std::string& response) const;
-
     // Connection thread management
     void perform_connection_async(const std::string& dev_id,
-                                   const std::string& base_url,
+                                   ConnectionSettings connection,
-                                   const std::string& api_key,
                                    uint64_t generation);
 
+    void refresh_webcam_info() const;
+    bool fetch_webcam_info(const ConnectionSettings& connection, uint64_t generation) const;
+
     // System-specific filament fetch methods
-    bool fetch_hh_filament_info(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_hh_filament_info(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
-    bool fetch_moonraker_filament_data(std::vector<AmsTrayData>& trays, int& max_lane_index);
+    bool fetch_moonraker_filament_data(const ConnectionSettings& connection, std::vector<AmsTrayData>& trays, int& max_lane_index);
 
     // JSON helper methods
     static std::string safe_json_string(const nlohmann::json& obj, const char* key);
@@ -188,15 +324,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;
+    // Next time the status loop may look the webcam up again (steady_clock ms).
+    mutable std::atomic<uint64_t> webcam_info_next_attempt_ms{0};
+    unsigned            thumbnail_lookup_attempts = 0;
+
+    static constexpr uint64_t WEBCAM_INFO_REFRESH_INTERVAL_MS = 30000;
+    static constexpr uint64_t WEBCAM_INFO_FAILURE_BACKOFF_MS  = 60000;
 
     std::atomic<int>       next_jsonrpc_id{1};
     std::set<std::string>  available_objects;  // Track for feature detection
+    bool                   assumed_light_on = false;
 
     std::atomic<bool>   ws_stop{false};
     std::atomic<bool>   ws_reconnect_requested{false};  // Flag to trigger reconnection
     std::atomic<uint64_t> ws_last_emit_ms{0};
     std::thread         ws_thread;
 
+    // Guards ws_thread and ws_abort. ws_abort posts to the stream's io_context, cancelling the
+    // reconnect wait and interrupting whatever connection attempt is running, so stop is prompt
+    // even when the stream thread is blocked on connect, TLS, or a read.
+    std::mutex            ws_abort_mutex;
+    std::function<void()> ws_abort;  // guarded by ws_abort_mutex
+
+    // AMS/filament refresh cadence, independent of telemetry dispatch so a steady
+    // stream of status updates can't starve it (ws_last_emit_ms is reset by those).
+    static constexpr uint64_t AMS_REFRESH_INTERVAL_MS = 10000;
+    std::atomic<uint64_t> ams_last_fetch_ms{0};
+
     // Throttling configuration for WebSocket updates
     // Critical changes (state transitions) dispatch immediately; telemetry is throttled
     static constexpr uint64_t STATUS_UPDATE_INTERVAL_MS = 1000;  // 1 update/sec for telemetry
@@ -206,7 +365,13 @@ private:
     // Connection thread management
     std::atomic<uint64_t>  connect_generation{0};
     std::thread            connect_thread;
-    std::recursive_mutex   connect_mutex;
+
+    void run_command_worker();
+    std::thread cmd_thread;
+    std::deque<std::function<void()>> cmd_queue;
+    std::mutex cmd_mutex;
+    std::condition_variable cmd_cv;
+    bool cmd_stop = false;
 };
 
 } // namespace Slic3r

src/slic3r/Utils/QidiPrinterAgent.cpp

@@ -2,18 +2,25 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
+#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
+#include <atomic>
 #include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/trim.hpp>
 #include <boost/algorithm/string/case_conv.hpp>
 #include <boost/log/trivial.hpp>
 #include <cctype>
+#include <cmath>
 #include "libslic3r/Preset.hpp"
+#include <cstddef>
+#include <exception>
 #include <map>
+#include <mutex>
 #include <sstream>
+#include <thread>
 #include <string>
 #include <utility>
 #include <vector>
@@ -34,6 +41,40 @@ bool has_visible_base_preset(const PresetCollection& filaments, const std::strin
     return false;
 }
 
+// RAII release of the in-flight fetch slot; movable so a failed thread start still releases it.
+struct InFlightGuard
+{
+    MoonrakerPrinterAgent* owner;
+    explicit InFlightGuard(MoonrakerPrinterAgent& o) noexcept : owner(&o) {}
+    InFlightGuard(InFlightGuard&& other) noexcept : owner(other.owner) { other.owner = nullptr; }
+    InFlightGuard(const InFlightGuard&) = delete;
+    InFlightGuard& operator=(const InFlightGuard&) = delete;
+    InFlightGuard& operator=(InFlightGuard&&) = delete;
+    ~InFlightGuard() { if (owner) owner->release_fetch_slot(); }
+};
+
+// nlohmann::json::value() returns the default only when the key is absent; a present but
+// null/wrong-typed value throws. Firmware JSON is untrusted, so read defensively.
+int read_int_or(const nlohmann::json& obj, const std::string& key, int fallback)
+{
+    auto it = obj.find(key);
+    if (it == obj.end()) {
+        return fallback;
+    }
+    if (it->is_number_integer()) {
+        return it->get<int>();
+    }
+    // Firmware may report an integral field as a JSON float (e.g. 2.0). Accept it only when it
+    // has no fractional part, so a genuinely fractional value falls back instead of truncating.
+    if (it->is_number_float()) {
+        const double value = it->get<double>();
+        if (value == std::floor(value)) {
+            return static_cast<int>(value);
+        }
+    }
+    return fallback;
+}
+
 } // anonymous namespace
 
 const std::string QidiPrinterAgent_VERSION = "0.0.1";
@@ -47,51 +88,179 @@ AgentInfo QidiPrinterAgent::get_agent_info_static()
     return AgentInfo{"qidi", "Qidi", QidiPrinterAgent_VERSION, "Qidi printer agent"};
 }
 
-bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
+FilamentSyncMode QidiPrinterAgent::get_filament_sync_mode() const
 {
-    std::string error;
+    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
+        return FilamentSyncMode::subscription;
+    return FilamentSyncMode::pull;
+}
 
-    // 1. Fetch device info and infer series_id
+bool QidiPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
-    std::string series_id;
+{
-    {
+    if (sync_mode != get_filament_sync_mode())
-        MoonrakerDeviceInfo info;
-        if (fetch_device_info(device_info.base_url, device_info.api_key, info, error)) {
-            series_id = infer_series_id(info.model_id, info.dev_name);
-        }
-    }
-    if (series_id.empty()) {
-        // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
-        series_id = infer_series_id(device_info.model_id, device_info.model_name);
-    }
-
-    // 2. Fetch filament dictionary
-    QidiFilamentDict dict;
-    if (!fetch_filament_dict(device_info.base_url, device_info.api_key, dict, error)) {
-        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
-    }
-
-    // 3. Fetch slot info and build AmsTrayData directly
-    std::vector<AmsTrayData> trays;
-    int                      box_count = 0;
-    if (!fetch_slot_info(device_info.base_url, device_info.api_key, dict, series_id, trays, box_count, error)) {
-        BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
         return false;
+
+    // Snapshot what the fetch needs; a reconnect can rewrite device_info meanwhile.
+    ConnectionSettings connection = get_connection_settings();
+    std::string        model_id;
+    std::string        model_name;
+    {
+        std::lock_guard<std::recursive_mutex> lock(connect_mutex);
+        model_id   = device_info.model_id;
+        model_name = device_info.model_name;
     }
 
-    // 4. Build the AMS payload
+    // One implementation for both modes; only where it runs differs. pull is the documented
-    build_ams_payload(box_count, box_count * 4 - 1, trays);
+    // blocking contract (the GUI thread reads DevFilaSystem right after the call), so it runs
+    // on the caller with the payload applied inline. subscription runs on a background thread
+    // so the status loop is not stalled, and the payload is marshalled back to the main thread.
+    auto work = [this, connection = std::move(connection), model_id, model_name](bool apply_inline) -> bool {
+        try {
+            std::string error;
+
+            // 1. Fetch device info and infer series_id
+            std::string series_id;
+            {
+                MoonrakerDeviceInfo info;
+                if (fetch_device_info(connection, info, error)) {
+                    series_id = infer_series_id(info.model_id, info.dev_name);
+                }
+            }
+            if (series_id.empty()) {
+                // Fall back to the configured Orca model if Moonraker doesn't expose a usable identifier.
+                series_id = infer_series_id(model_id, model_name);
+            }
+
+            // 2. Fetch filament dictionary
+            QidiFilamentDict dict;
+            if (!fetch_filament_dict(connection, dict, error)) {
+                BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch filament dict: " << error;
+            }
+
+            // 3. Fetch slot info and build AmsTrayData directly
+            std::vector<AmsTrayData> trays;
+            int box_count = 0;
+            if (!fetch_slot_info(connection, dict, series_id, trays, box_count, error)) {
+                BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::fetch_filament_info: Failed to fetch slot info: " << error;
+                return false;
+            }
+
+            // 4. Build the AMS payload, resolving preset-dependent ids on the main thread.
+            auto resolve_ids = [](std::vector<AmsTrayData>& resolved_trays) {
+                auto* bundle = GUI::wxGetApp().preset_bundle;
+                if (!bundle) {
+                    return; // keep the Qidi-specific ids computed from device data
+                }
+                for (auto& tray : resolved_trays) {
+                    if (!tray.has_filament) {
+                        continue;
+                    }
+                    if (!tray.tray_info_idx.empty() && has_visible_base_preset(bundle->filaments, tray.tray_info_idx)) {
+                        continue;
+                    }
+                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
+                }
+            };
+            build_ams_payload(box_count, box_count * 4 - 1, trays, apply_inline, resolve_ids);
+            return true;
+        } catch (const std::exception& e) {
+            // why: an exception escaping a detached thread is std::terminate, and firmware
+            // JSON is untrusted; mirror run_command_worker and swallow it here.
+            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::fetch_filament_info: unhandled exception: " << e.what();
+            return false;
+        } catch (...) {
+            BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::fetch_filament_info: unhandled exception";
+            return false;
+        }
+    };
+
+    if (sync_mode == FilamentSyncMode::pull) {
+        return work(/*apply_inline=*/true);
+    }
+
+    // Subscription: fire-and-forget. A `true` return means the refresh was scheduled (or is
+    // already running), not that DevFilaSystem has been updated. Reserve under the same mutex
+    // shutdown() uses, so the flag and the count can't race.
+    {
+        std::lock_guard<std::mutex> lock(fetch_lifecycle_mutex);
+        if (shutting_down.load())
+            return false;
+        if (filament_fetch_in_flight.load() > 0)
+            return true; // a fetch is already running; don't pile on
+        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
+    }
+
+    InFlightGuard guard{*this};
+    std::thread([work = std::move(work), guard = std::move(guard)]() mutable {
+        work(/*apply_inline=*/false);
+    }).detach();
     return true;
 }
 
-bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
+bool QidiPrinterAgent::apply_box_mapping(const PrintParams& params) const
-                                       const std::string&        api_key,
+{
+    // enable_box mirrors task_use_ams: engage the multi-color box only when this
+    // job actually routes filament through it. (See qidi-ams-findings.md §2/§8.3 —
+    // if firmware treats enable_box as "a box exists" rather than "use it this job",
+    // switch this gate to HasAms()/box_count instead.)
+    const int         enable = params.task_use_ams ? 1 : 0;
+    const std::string dev_id = get_connection_settings().dev_id;
+
+    // Build one gcode/script request instead of N blocking HTTP calls: apply_box_mapping
+    // runs on the caller's (GUI) thread before the print starts, so per-tool round trips
+    // would freeze the UI.
+    std::string script = "SAVE_VARIABLE VARIABLE=enable_box VALUE=" + std::to_string(enable);
+
+    // When the box isn't used this job, leave the existing value_t<tool> slot
+    // assignments untouched (enable_box=0 is enough to disengage it).
+    if (enable) {
+        if (params.ams_mapping.empty()) {
+            BOOST_LOG_TRIVIAL(warning) << "QidiPrinterAgent::apply_box_mapping: enable_box set but ams_mapping is empty";
+        } else {
+            // ams_mapping (v0) is a JSON array indexed by filament/tool; each value is the
+            // physical box slot (-1 = unmapped). Mirror it onto value_t<tool>.
+            auto mapping = nlohmann::json::parse(params.ams_mapping, nullptr, /*allow_exceptions*/ false);
+            if (mapping.is_discarded() || !mapping.is_array()) {
+                BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: invalid ams_mapping: " << params.ams_mapping;
+                return false;
+            }
+            for (size_t tool = 0; tool < mapping.size(); ++tool) {
+                if (!mapping[tool].is_number_integer())
+                    continue;
+                const int slot = mapping[tool].get<int>();
+                if (slot < 0)
+                    continue; // unmapped filament — skip
+                script += "\nSAVE_VARIABLE VARIABLE=value_t" + std::to_string(tool) +
+                          " VALUE=\"'slot" + std::to_string(slot) + "'\"";
+            }
+        }
+    }
+
+    if (!send_gcode(dev_id, script)) {
+        BOOST_LOG_TRIVIAL(error) << "QidiPrinterAgent::apply_box_mapping: failed to send box mapping";
+        return false;
+    }
+    return true;
+}
+
+int QidiPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
+{
+    // Only the LAN print path is implemented by the Moonraker base; the box config is emitted
+    // here, before the print starts. The cloud/record/sdcard variants inherited from the base
+    // deliberately return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED without side effects.
+    if (!apply_box_mapping(params))
+        return BAMBU_NETWORK_ERR_PRINT_LP_PUBLISH_MSG_FAILED;
+    return MoonrakerPrinterAgent::start_local_print(std::move(params), update_fn, cancel_fn);
+}
+
+bool QidiPrinterAgent::fetch_slot_info(const ConnectionSettings& connection,
                                        const QidiFilamentDict&   dict,
                                        const std::string&        series_id,
                                        std::vector<AmsTrayData>& trays,
                                        int&                      box_count,
                                        std::string&              error)
 {
-    std::string url = join_url(base_url, "/printer/objects/query?save_variables=variables");
+    std::string url = join_url(connection.base_url, "/printer/objects/query?save_variables=variables");
     for (int i = 0; i < 16; ++i) {
         url += "&box_stepper%20slot" + std::to_string(i) + "=runout_button";
     }
@@ -101,8 +270,9 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
     std::string http_error;
 
     auto http = Http::get(url);
-    if (!api_key.empty()) {
+    configure_http(http, connection);
-        http.header("X-Api-Key", api_key);
+    if (!connection.api_key.empty()) {
+        http.header("X-Api-Key", connection.api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)
@@ -127,22 +297,12 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
         return false;
     }
 
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    nlohmann::json status;
-    if (json.is_discarded()) {
+    nlohmann::json variables;
-        error = "Invalid JSON response";
+    if (!parse_slot_response(response_body, status, variables, error))
         return false;
-    }
 
-    if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("save_variables") ||
+    box_count = read_int_or(variables, "box_count", 1);
-        !json["result"]["status"]["save_variables"].contains("variables")) {
-        error = "Unexpected JSON structure";
-        return false;
-    }
-
-    auto& variables = json["result"]["status"]["save_variables"]["variables"];
-    auto& status    = json["result"]["status"];
-
-    box_count = variables.value("box_count", 1);
     if (box_count < 0) {
         box_count = 0;
     }
@@ -165,9 +325,9 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
         tray.slot_index = i;
 
         // Read slot variables
-        const int color_index     = variables.value("color_slot" + std::to_string(i), 1);
+        const int color_index     = read_int_or(variables, "color_slot" + std::to_string(i), 1);
-        const int filament_type   = variables.value("filament_slot" + std::to_string(i), 1);
+        const int filament_type   = read_int_or(variables, "filament_slot" + std::to_string(i), 1);
-        const int vendor_type     = variables.value("vendor_slot" + std::to_string(i), 0);
+        const int vendor_type     = read_int_or(variables, "vendor_slot" + std::to_string(i), 0);
 
         // Check filament presence via runout sensor
         std::string box_stepper_key = "box_stepper slot" + std::to_string(i);
@@ -175,7 +335,7 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
         if (status.contains(box_stepper_key)) {
             auto& box_stepper = status[box_stepper_key];
             if (box_stepper.contains("runout_button") && !box_stepper["runout_button"].is_null()) {
-                int runout_button = box_stepper["runout_button"].template get<int>();
+                const int runout_button = read_int_or(box_stepper, "runout_button", 0);
                 tray.has_filament = (runout_button == 0);
             }
         }
@@ -189,16 +349,9 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
             }
             tray.tray_type = normalize_filament_type(filament_name);
 
-            // Try Qidi-specific setting ID first; fall back to visible preset by type
+            // Qidi-specific setting id derived from device data only; the preset-dependent
-            std::string setting_id = build_setting_id(filament_type, vendor_type, tray.tray_type);
+            // fallback runs on the main thread in the resolve hook passed to build_ams_payload.
-            auto* bundle = GUI::wxGetApp().preset_bundle;
+            tray.tray_info_idx = build_setting_id(filament_type, vendor_type, tray.tray_type);
-            if (!bundle) {
-                tray.tray_info_idx = setting_id;
-            } else if (!setting_id.empty() && has_visible_base_preset(bundle->filaments, setting_id)) {
-                tray.tray_info_idx = setting_id;
-            } else {
-                tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
-            }
 
             // Look up color from dictionary
             auto color_it = dict.colors.find(color_index);
@@ -215,20 +368,45 @@ bool QidiPrinterAgent::fetch_slot_info(const std::string&        base_url,
     return true;
 }
 
-bool QidiPrinterAgent::fetch_filament_dict(const std::string& base_url,
+bool QidiPrinterAgent::parse_slot_response(const std::string& response_body,
-                                           const std::string& api_key,
+                                           nlohmann::json&    status,
+                                           nlohmann::json&    variables,
+                                           std::string&       error)
+{
+    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+    if (json.is_discarded()) {
+        error = "Invalid JSON response";
+        return false;
+    }
+
+    if (!json.is_object() || !json.contains("result") || !json["result"].is_object() || !json["result"].contains("status") ||
+        !json["result"]["status"].is_object() || !json["result"]["status"].contains("save_variables") ||
+        !json["result"]["status"]["save_variables"].is_object() || !json["result"]["status"]["save_variables"].contains("variables") ||
+        !json["result"]["status"]["save_variables"]["variables"].is_object()) {
+        // why: Qidi firmware may send null here, but json::value() throws for it.
+        error = "Unexpected JSON structure: save_variables.variables must be an object";
+        return false;
+    }
+
+    status    = json["result"]["status"];
+    variables = status["save_variables"]["variables"];
+    return true;
+}
+
+bool QidiPrinterAgent::fetch_filament_dict(const ConnectionSettings& connection,
                                            QidiFilamentDict& dict,
                                            std::string& error) const
 {
-    std::string url = join_url(base_url, "/server/files/config/officiall_filas_list.cfg");
+    std::string url = join_url(connection.base_url, "/server/files/config/officiall_filas_list.cfg");
 
     std::string response_body;
     bool        success = false;
     std::string http_error;
 
     auto http = Http::get(url);
-    if (!api_key.empty()) {
+    configure_http(http, connection);
-        http.header("X-Api-Key", api_key);
+    if (!connection.api_key.empty()) {
+        http.header("X-Api-Key", connection.api_key);
     }
     http.timeout_connect(5)
         .timeout_max(10)

src/slic3r/Utils/QidiPrinterAgent.hpp

@@ -3,6 +3,8 @@
 
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
+#include "bambu_networking.hpp"
+#include "nlohmann/json_fwd.hpp"
 
 #include <map>
 #include <string>
@@ -14,7 +16,7 @@ class QidiPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit QidiPrinterAgent(std::string log_dir);
-    ~QidiPrinterAgent() override = default;
+    ~QidiPrinterAgent() override { shutdown(); }
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
@@ -22,7 +24,22 @@ public:
     // Override filament sync (Qidi-specific implementation)
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
 
+    static bool parse_slot_response(const std::string& response_body,
+                                    nlohmann::json&    status,
+                                    nlohmann::json&    variables,
+                                    std::string&       error);
+
+    // Print operations — emit QiDi multi-color box config, then delegate to base.
+    // Only the LAN print path is supported by the base; the cloud/record/sdcard variants
+    // are inherited and return ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED.
+    int start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn) override;
+
+    FilamentSyncMode get_filament_sync_mode() const override;
+
 private:
+    // Push enable_box + value_t<tool> SAVE_VARIABLEs before a print starts.
+    // Returns false if any command fails (caller should abort the print).
+    bool apply_box_mapping(const PrintParams& params) const;
     struct QidiFilamentDict
     {
         std::map<int, std::string> colors;
@@ -30,14 +47,13 @@ private:
     };
 
     // Qidi-specific methods
-    bool fetch_slot_info(const std::string&        base_url,
+    bool fetch_slot_info(const ConnectionSettings& connection,
-                         const std::string&        api_key,
                          const QidiFilamentDict&   dict,
                          const std::string&        series_id,
                          std::vector<AmsTrayData>& trays,
                          int&                      box_count,
                          std::string&              error);
-    bool fetch_filament_dict(const std::string& base_url, const std::string& api_key, QidiFilamentDict& dict, std::string& error) const;
+    bool fetch_filament_dict(const ConnectionSettings& connection, QidiFilamentDict& dict, std::string& error) const;
     std::string normalize_filament_type(const std::string& filament_type);
     std::string infer_series_id(const std::string& model_id, const std::string& dev_name);
     std::string normalize_model_key(std::string value);

src/slic3r/Utils/SnapmakerPrinterAgent.cpp

@@ -2,11 +2,20 @@
 #include "Http.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 #include "IPrinterAgent.hpp"
+#include "bambu_networking.hpp"
 #include "libslic3r/PresetBundle.hpp"
 #include "slic3r/GUI/GUI_App.hpp"
 
 #include "nlohmann/json.hpp"
+#include <atomic>
 #include <boost/log/trivial.hpp>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <exception>
+#include <mutex>
+#include <sstream>
+#include <thread>
 #include <vector>
 #include <string>
 #include "libslic3r/Preset.hpp"
@@ -18,6 +27,91 @@ namespace Slic3r {
 namespace {
 
 constexpr const char* SNAPMAKER_AGENT_VERSION = "0.0.1";
+constexpr int64_t     CAMERA_REFRESH_INTERVAL_MS = 300'000;
+
+int64_t now_ms()
+{
+    return std::chrono::duration_cast<std::chrono::milliseconds>(
+        std::chrono::steady_clock::now().time_since_epoch()).count();
+}
+
+// RAII release of the in-flight fetch slot; movable so a failed thread start still releases it.
+struct InFlightGuard
+{
+    MoonrakerPrinterAgent* owner;
+    explicit InFlightGuard(MoonrakerPrinterAgent& o) noexcept : owner(&o) {}
+    InFlightGuard(InFlightGuard&& other) noexcept : owner(other.owner) { other.owner = nullptr; }
+    InFlightGuard(const InFlightGuard&) = delete;
+    InFlightGuard& operator=(const InFlightGuard&) = delete;
+    InFlightGuard& operator=(InFlightGuard&&) = delete;
+    ~InFlightGuard() { if (owner) owner->release_fetch_slot(); }
+};
+
+// nlohmann::json::value() returns the default only when the key is absent; a present but
+// null/wrong-typed value throws. Firmware JSON is untrusted, so read defensively.
+int read_int_or(const nlohmann::json& obj, const char* key, int fallback)
+{
+    auto it = obj.find(key);
+    if (it == obj.end()) {
+        return fallback;
+    }
+    if (it->is_number_integer()) {
+        return it->get<int>();
+    }
+    // Firmware may report an integral field as a JSON float (e.g. 2.0). Accept it only when it
+    // has no fractional part, so a genuinely fractional value falls back instead of truncating.
+    if (it->is_number_float()) {
+        const double value = it->get<double>();
+        if (value == std::floor(value)) {
+            return static_cast<int>(value);
+        }
+    }
+    return fallback;
+}
+
+std::vector<std::string> read_string_array_or(const nlohmann::json& obj, const char* key)
+{
+    auto it = obj.find(key);
+    if (it == obj.end() || !it->is_array())
+        return {};
+    std::vector<std::string> out;
+    out.reserve(it->size());
+    for (const auto& v : *it)
+        out.push_back(v.is_string() ? v.get<std::string>() : std::string{});
+    return out;
+}
+
+std::vector<bool> read_bool_array_or(const nlohmann::json& obj, const char* key)
+{
+    auto it = obj.find(key);
+    if (it == obj.end() || !it->is_array())
+        return {};
+    std::vector<bool> out;
+    out.reserve(it->size());
+    for (const auto& v : *it)
+        out.push_back(v.is_boolean() ? v.get<bool>() : false);
+    return out;
+}
+
+// Parse a hex colour, stopping at the first non-hex character. std::stoul throws on
+// empty/non-hex input, which must not escape the detached fetch thread.
+unsigned int parse_hex_color(const std::string& hex)
+{
+    unsigned int value = 0;
+    for (char c : hex) {
+        int digit;
+        if (c >= '0' && c <= '9')
+            digit = c - '0';
+        else if (c >= 'a' && c <= 'f')
+            digit = c - 'a' + 10;
+        else if (c >= 'A' && c <= 'F')
+            digit = c - 'A' + 10;
+        else
+            break;
+        value = (value << 4) | static_cast<unsigned int>(digit);
+    }
+    return value;
+}
 
 // Safely access a parallel array by index, returning a fallback if out of bounds.
 template<typename T>
@@ -40,14 +134,16 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
             filaments.get_preset_base(p) == &p && p.config.opt_string("filament_vendor", 0u) == vendor_name &&
             p.config.opt_string("filament_type", 0u) == filament_type) {
             // The printer returns RGBA in the format RRGGBBAA, but profiles store color as #RRGGBB,
-            // so we must remove # and ignore alpha channel for distance calculation
+            // so we must remove # and ignore alpha channel for distance calculation. Firmware
-            unsigned int target_color_value = std::stoul(color_rgba.substr(0, color_rgba.length() - 2), nullptr, 16);
+            // colours are untrusted; parse_hex_color tolerates empty/non-hex instead of throwing.
+            unsigned int target_color_value =
+                parse_hex_color(color_rgba.substr(0, color_rgba.size() >= 2 ? color_rgba.size() - 2 : 0));
 
             std::string  p_color = p.config.opt_string("default_filament_colour", 0u);
-            unsigned int p_color_value;
+            unsigned int p_color_value = 0;
             if (!p_color.empty()) {
-                size_t       hash_pos = p_color.find("#");
+                size_t hash_pos = p_color.find("#");
-                p_color_value         = std::stoul(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0), nullptr, 16);
+                p_color_value   = parse_hex_color(p_color.substr(hash_pos != std::string::npos ? hash_pos + 1 : 0));
             } else {
                 // Default to black if no color specified in profile. Assume other profiles might be a closer color match.
                 // Could be a problem if the target color is also black and there exist a specific profile for that type, vendor and color
@@ -74,6 +170,31 @@ std::string find_closest_color_preset_by_vendor_and_type(const PresetCollection&
 
 SnapmakerPrinterAgent::SnapmakerPrinterAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
 
+void SnapmakerPrinterAgent::start_camera_monitor()
+{
+    enqueue_command([this] {
+        send_ws_rpc("camera.start_monitor",
+                    {{"domain", "lan"}, {"interval", 0}, {"expect_pw", false}});
+    });
+    m_camera_last_fire_ms.store(now_ms());
+}
+
+void SnapmakerPrinterAgent::on_status_loop_tick(const std::string& dev_id)
+{
+    (void) dev_id;
+    const int64_t last = m_camera_last_fire_ms.load();
+    if (last == 0 || now_ms() - last >= CAMERA_REFRESH_INTERVAL_MS) {
+        start_camera_monitor();
+    }
+}
+
+int SnapmakerPrinterAgent::command_start_camera(std::string dev_id)
+{
+    (void) dev_id;
+    start_camera_monitor();
+    return BAMBU_NETWORK_SUCCESS;
+}
+
 AgentInfo SnapmakerPrinterAgent::get_agent_info_static()
 {
     return AgentInfo{"snapmaker", "Snapmaker", SNAPMAKER_AGENT_VERSION, "Snapmaker printer agent"};
@@ -109,127 +230,192 @@ std::string SnapmakerPrinterAgent::combine_filament_type(const std::string& type
     return base;
 }
 
-bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode /*sync_mode*/)
+bool SnapmakerPrinterAgent::fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode)
 {
-    std::string url = join_url(device_info.base_url, "/printer/objects/query?print_task_config&filament_detect");
+    (void) dev_id;
+    if (sync_mode != get_filament_sync_mode())
+        return false;
 
-    std::string response_body;
+    // Snapshot everything the fetch needs (URL, api key, TLS/CA): a reconnect can rewrite
-    bool        success = false;
+    // device_info meanwhile.
-    std::string http_error;
+    const ConnectionSettings connection = get_connection_settings();
 
-    auto http = Http::get(url);
+    // One implementation for both modes; only where it runs differs. pull is the documented
-    if (!device_info.api_key.empty()) {
+    // blocking contract (the GUI thread reads DevFilaSystem right after the call), so it runs
-        http.header("X-Api-Key", device_info.api_key);
+    // on the caller with the payload applied inline. subscription runs on a background thread
-    }
+    // so the status loop is not stalled, and the payload is marshalled back to the main thread.
-    http.timeout_connect(5)
+    auto work = [this, connection](bool apply_inline) -> bool {
-        .timeout_max(10)
+        try {
-        .on_complete([&](std::string body, unsigned status) {
+            const std::string url = join_url(connection.base_url, "/printer/objects/query?print_task_config&filament_detect");
-            if (status == 200) {
+
-                response_body = body;
+            std::string response_body;
-                success       = true;
+            bool success = false;
-            } else {
+            std::string http_error;
-                http_error = "HTTP error: " + std::to_string(status);
+
+            auto http = Http::get(url);
+            configure_http(http, connection);
+            if (!connection.api_key.empty()) {
+                http.header("X-Api-Key", connection.api_key);
             }
-        })
+            http.timeout_connect(5)
-        .on_error([&](std::string body, std::string err, unsigned status) {
+                .timeout_max(10)
-            http_error = err;
+                .on_complete([&](std::string body, unsigned status) {
-            if (status > 0) {
+                    if (status == 200) {
-                http_error += " (HTTP " + std::to_string(status) + ")";
+                        response_body = body;
+                        success       = true;
+                    } else {
+                        http_error = "HTTP error: " + std::to_string(status);
+                    }
+                })
+                .on_error([&](std::string body, std::string err, unsigned status) {
+                    http_error = err;
+                    if (status > 0) {
+                        http_error += " (HTTP " + std::to_string(status) + ")";
+                    }
+                })
+                .perform_sync();
+
+            if (!success) {
+                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
+                return false;
             }
-        })
-        .perform_sync();
 
-    if (!success) {
+            auto json = nlohmann::json::parse(response_body, nullptr, false, true);
-        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: HTTP request failed: " << http_error;
+            if (json.is_discarded()) {
-        return false;
+                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
-    }
+                return false;
+            }
 
-    auto json = nlohmann::json::parse(response_body, nullptr, false, true);
+            // Navigate to result.status.print_task_config
-    if (json.is_discarded()) {
+            if (!json.contains("result") || !json["result"].contains("status") || !json["result"]["status"].contains("print_task_config")) {
-        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Invalid JSON response";
+                BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
-        return false;
+                return false;
-    }
+            }
 
-    // Navigate to result.status.print_task_config
+            auto& ptc = json["result"]["status"]["print_task_config"];
-    if (!json.contains("result") || !json["result"].contains("status") ||
-        !json["result"]["status"].contains("print_task_config")) {
-        BOOST_LOG_TRIVIAL(warning) << "SnapmakerPrinterAgent::fetch_filament_info: Missing print_task_config in response";
-        return false;
-    }
 
-    auto& ptc = json["result"]["status"]["print_task_config"];
+            // Read parallel arrays from print_task_config
+            auto filament_exist    = read_bool_array_or(ptc, "filament_exist");
+            auto filament_type     = read_string_array_or(ptc, "filament_type");
+            auto filament_sub_type = read_string_array_or(ptc, "filament_sub_type");
+            auto filament_color    = read_string_array_or(ptc, "filament_color_rgba");
+            auto filament_vendor   = read_string_array_or(ptc, "filament_vendor");
 
-    // Read parallel arrays from print_task_config
+            const int slot_count = static_cast<int>(filament_exist.size());
-    auto filament_exist    = ptc.value("filament_exist", std::vector<bool>{});
+            if (slot_count == 0) {
-    auto filament_type     = ptc.value("filament_type", std::vector<std::string>{});
+                BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
-    auto filament_sub_type = ptc.value("filament_sub_type", std::vector<std::string>{});
+                return false;
-    auto filament_color    = ptc.value("filament_color_rgba", std::vector<std::string>{});
+            }
-    auto filament_vendor   = ptc.value("filament_vendor", std::vector<std::string>{});
 
-    const int slot_count = static_cast<int>(filament_exist.size());
+            // Read NFC filament_detect data for temperature info (optional)
-    if (slot_count == 0) {
+            nlohmann::json nfc_info;
-        BOOST_LOG_TRIVIAL(info) << "SnapmakerPrinterAgent::fetch_filament_info: No filament slots reported";
+            if (json["result"]["status"].contains("filament_detect") && json["result"]["status"]["filament_detect"].contains("info")) {
-        return false;
+                nfc_info = json["result"]["status"]["filament_detect"]["info"];
-    }
+            }
 
-    // Read NFC filament_detect data for temperature info (optional)
+            static const std::string empty_str;
-    nlohmann::json nfc_info;
+            static const std::string default_color = "FFFFFFFF";
-    if (json["result"]["status"].contains("filament_detect") &&
-        json["result"]["status"]["filament_detect"].contains("info")) {
-        nfc_info = json["result"]["status"]["filament_detect"]["info"];
-    }
 
-    static const std::string empty_str;
+            // Per-tray vendor names, kept so the preset lookup can run on the main thread.
-    static const std::string default_color = "FFFFFFFF";
+            std::vector<std::string> vendors(slot_count);
 
-    std::vector<AmsTrayData> trays;
+            std::vector<AmsTrayData> trays;
-    trays.reserve(slot_count);
+            trays.reserve(slot_count);
 
-    for (int i = 0; i < slot_count; ++i) {
+            for (int i = 0; i < slot_count; ++i) {
-        AmsTrayData tray;
+                AmsTrayData tray;
-        tray.slot_index   = i;
+                tray.slot_index   = i;
-        tray.has_filament = filament_exist[i];
+                tray.has_filament = filament_exist[i];
 
-        if (tray.has_filament) {
+                if (tray.has_filament) {
-            tray.tray_type     = combine_filament_type(safe_at(filament_type, i, empty_str),
+                    tray.tray_type  = combine_filament_type(safe_at(filament_type, i, empty_str), safe_at(filament_sub_type, i, empty_str));
-                                                       safe_at(filament_sub_type, i, empty_str));
+                    tray.tray_color = safe_at(filament_color, i, default_color);
-            tray.tray_color    = safe_at(filament_color, i, default_color);
+                    vendors[i]      = safe_at(filament_vendor, i, empty_str);
 
-            auto* bundle = GUI::wxGetApp().preset_bundle;
+                    // Generic id derived from device data only; the preset-dependent lookup runs
-            // Try to find a matching preset for this filament based on vendor, type and color.
+                    // on the main thread in the resolve hook passed to build_ams_payload.
-            // If not found, default to traditional search by type only or generic type mapping.
+                    tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
-            if (bundle) {
-                std::string vendor      = safe_at(filament_vendor, i, empty_str);
-                std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendor, tray.tray_type,
-                                                                                       tray.tray_color);
 
-                if (!filament_id.empty()) {
+                    // Extract NFC temperature data if available
-                    tray.tray_info_idx = filament_id;
+                    if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
-                    BOOST_LOG_TRIVIAL(warning) << "Filament sync: Found manufacturer-specific profile for slot " << i << ": "
+                        auto&       nfc_slot = nfc_info[i];
-                                               << filament_id;
+                        std::string vendor   = "NONE";
-                } else {
+                        if (auto vendor_it = nfc_slot.find("VENDOR"); vendor_it != nfc_slot.end() && vendor_it->is_string()) {
-                    tray.tray_info_idx = bundle->filaments.filament_id_by_type(tray.tray_type);
+                            vendor = vendor_it->get<std::string>();
+                        }
+                        if (vendor != "NONE" && !vendor.empty()) {
+                            tray.bed_temp    = read_int_or(nfc_slot, "BED_TEMP", 0);
+                            tray.nozzle_temp = read_int_or(nfc_slot, "FIRST_LAYER_TEMP", 0);
+                        }
+                    }
                 }
-            } else {
+
-                tray.tray_info_idx = map_filament_type_to_generic_id(tray.tray_type);
+                trays.emplace_back(std::move(tray));
             }
 
-            // Extract NFC temperature data if available
+            // Resolve against GUI-owned presets on the main thread (inside build_ams_payload).
-            if (nfc_info.is_array() && i < static_cast<int>(nfc_info.size()) && nfc_info[i].is_object()) {
+            auto resolve_ids = [vendors](std::vector<AmsTrayData>& resolved_trays) {
-                auto& nfc_slot = nfc_info[i];
+                auto* bundle = GUI::wxGetApp().preset_bundle;
-                std::string vendor = nfc_slot.value("VENDOR", "NONE");
+                if (!bundle) {
-                if (vendor != "NONE" && !vendor.empty()) {
+                    return; // keep the generic ids computed from device data
-                    tray.bed_temp    = nfc_slot.value("BED_TEMP", 0);
-                    tray.nozzle_temp = nfc_slot.value("FIRST_LAYER_TEMP", 0);
                 }
-            }
+                for (size_t i = 0; i < resolved_trays.size() && i < vendors.size(); ++i) {
+                    AmsTrayData& tray = resolved_trays[i];
+                    if (!tray.has_filament) {
+                        continue;
+                    }
+                    // Prefer a manufacturer/colour-specific preset, else fall back to type.
+                    std::string filament_id = find_closest_color_preset_by_vendor_and_type(bundle->filaments, vendors[i], tray.tray_type,
+                                                                                           tray.tray_color);
+                    tray.tray_info_idx = filament_id.empty() ? bundle->filaments.filament_id_by_type(tray.tray_type) : filament_id;
+                }
+            };
+            build_ams_payload(1, slot_count - 1, trays, apply_inline, resolve_ids);
+            return true;
+        } catch (const std::exception& e) {
+            // why: an exception escaping a detached thread is std::terminate, and firmware
+            // JSON is untrusted; mirror run_command_worker and swallow it here.
+            BOOST_LOG_TRIVIAL(error) << "SnapmakerPrinterAgent::fetch_filament_info: unhandled exception: " << e.what();
+            return false;
+        } catch (...) {
+            BOOST_LOG_TRIVIAL(error) << "SnapmakerPrinterAgent::fetch_filament_info: unhandled exception";
+            return false;
         }
+    };
 
-        trays.emplace_back(std::move(tray));
+    if (sync_mode == FilamentSyncMode::pull) {
+        return work(/*apply_inline=*/true);
     }
 
-    build_ams_payload(1, slot_count - 1, trays);
+    // Subscription: fire-and-forget. A `true` return means the refresh was scheduled (or is
+    // already running), not that DevFilaSystem has been updated. Reserve under the same mutex
+    // shutdown() uses, so the flag and the count can't race.
+    {
+        std::lock_guard<std::mutex> lock(fetch_lifecycle_mutex);
+        if (shutting_down.load())
+            return false;
+        if (filament_fetch_in_flight.load() > 0)
+            return true; // a fetch is already running; don't pile on
+        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
+    }
+
+    InFlightGuard guard{*this};
+    std::thread([work = std::move(work), guard = std::move(guard)]() mutable {
+        work(/*apply_inline=*/false);
+    }).detach();
     return true;
 }
 
+std::string SnapmakerPrinterAgent::get_camera_url() const
+{
+    return join_url(get_connection_settings().base_url, "/server/files/camera/monitor.jpg");
+}
+
+FilamentSyncMode SnapmakerPrinterAgent::get_filament_sync_mode() const
+{
+    if (GUI::wxGetApp().app_config->get_bool("use_printer_agents"))
+        return FilamentSyncMode::subscription;
+    return FilamentSyncMode::pull;
+}
+
 } // namespace Slic3r

src/slic3r/Utils/SnapmakerPrinterAgent.hpp

@@ -3,6 +3,8 @@
 #include "IPrinterAgent.hpp"
 #include "MoonrakerPrinterAgent.hpp"
 
+#include <atomic>
+#include <cstdint>
 #include <string>
 
 namespace Slic3r {
@@ -11,16 +13,25 @@ class SnapmakerPrinterAgent final : public MoonrakerPrinterAgent
 {
 public:
     explicit SnapmakerPrinterAgent(std::string log_dir);
-    ~SnapmakerPrinterAgent() override = default;
+    ~SnapmakerPrinterAgent() override { shutdown(); }
 
     static AgentInfo get_agent_info_static();
     AgentInfo        get_agent_info() override { return get_agent_info_static(); }
 
     bool fetch_filament_info(std::string dev_id, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override;
+    FilamentSyncMode get_filament_sync_mode() const override;
+    int command_start_camera(std::string dev_id) override;
+    CameraStreamMode get_camera_stream_mode() const override { return CameraStreamMode::http_snapshot; }
+    std::string get_camera_url() const override;
 
 private:
     // Combine filament_type + filament_sub_type into a unified type string
     static std::string combine_filament_type(const std::string& type, const std::string& sub_type);
+
+    void start_camera_monitor();
+    void on_status_loop_tick(const std::string& dev_id) override;
+
+    std::atomic<int64_t> m_camera_last_fire_ms{0};
 };
 
 } // namespace Slic3r

tests/fff_print/test_perimeters.cpp

@@ -22,6 +22,7 @@
 #include "libslic3r/ClipperUtils.hpp"
 #include "libslic3r/ExPolygon.hpp"
 #include "libslic3r/Point.hpp"
+#include "libslic3r/Polygon.hpp"
 #include "libslic3r/Polyline.hpp"
 #include <limits>
 #include <string>
@@ -994,3 +995,384 @@ TEST_CASE("A hole whose outer wall touches the contour's runs with it", "[Perime
         CHECK(layers[i].holes_ccw.front() == ccw);
     }
 }
+
+namespace {
+
+// The outer radius of round_tube().
+const double tube_radius = 11.5;
+
+// Every setting the tube walls below are measured against. With 0.5mm walls a 1mm tube wall holds only the two
+// outer walls, touching, and every further 0.5mm makes room for one more inner wall.
+DynamicPrintConfig tube_config(const char *wall_generator, int wall_loops)
+{
+    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({
+        { "wall_generator",             wall_generator },
+        { "wall_loops",                 wall_loops },
+        { "wall_sequence",              "inner wall/outer wall" },
+        { "wall_direction",             "ccw" },
+        { "layer_height",               0.2 },
+        { "initial_layer_print_height", 0.2 },
+        { "nozzle_diameter",            "0.4" },
+        { "outer_wall_line_width",      0.5 },
+        { "inner_wall_line_width",      0.5 },
+        { "precise_outer_wall",         true },
+        { "detect_thin_wall",           false },
+        { "only_one_wall_top",          false },
+        { "only_one_wall_first_layer",  false },
+        { "brim_type",                  "no_brim" },
+        { "detect_overhang_wall",       true },
+        { "overhang_reverse",           false },
+        { "overhang_reverse_threshold", "0%" },
+    });
+    return config;
+}
+
+// A 2mm tall round tube whose wall is `wall` mm thick.
+Print &round_tube(Print &print, Model &model, const DynamicPrintConfig &config, double wall)
+{
+    ModelObject *object = model.add_object();
+    object->name = "round_tube.stl";
+    object->add_volume(make_cylinder(tube_radius, 2.), ModelVolumeType::MODEL_PART, false);
+    object->add_volume(make_cylinder(tube_radius - wall, 2.), ModelVolumeType::NEGATIVE_VOLUME, false);
+    object->add_instance();
+    object->ensure_on_bed();
+
+    print.auto_assign_extruders(object);
+    print.apply(model, config);
+    print.validate();
+    print.set_status_silent();
+    print.process();
+    return print;
+}
+
+// The side of the tube wall a wall loop lies on. The centre is the middle of the tube wall, where Arachne lays the
+// inner wall both sides share when the tube wall is too narrow for a pair of them.
+enum class TubeSide { Contour, Hole, Centre };
+
+struct TubeLoop {
+    TubeSide side;
+    int      inset;
+    bool     ccw;
+};
+
+// The wall loops of every layer of round_tube() in extrusion order.
+std::vector<std::vector<TubeLoop>> tube_loops(const Print &print, double wall)
+{
+    const double centre = tube_radius - 0.5 * wall;
+    std::vector<std::vector<TubeLoop>> out;
+    for (const Layer *layer : print.objects().front()->layers()) {
+        const Vec2d axis = get_extents(layer->lslices).center().cast<double>();
+        std::vector<TubeLoop> &loops = out.emplace_back();
+        for (const LayerRegion *region : layer->regions())
+            for (const ExtrusionEntity *entity : region->perimeters.flatten().entities) {
+                if (! entity->is_loop())
+                    continue;
+                const ExtrusionLoop *loop    = static_cast<const ExtrusionLoop*>(entity);
+                const Polygon        polygon = loop->polygon();
+                double               radius  = 0.;
+                for (const Point &p : polygon.points)
+                    radius += unscaled<double>((p.cast<double>() - axis).norm());
+                radius /= double(polygon.points.size());
+                const TubeSide side = radius > centre + 0.1 ? TubeSide::Contour : radius < centre - 0.1 ? TubeSide::Hole : TubeSide::Centre;
+                loops.push_back({ side, loop->inset_idx, polygon.is_counter_clockwise() });
+            }
+    }
+    return out;
+}
+
+// The insets one side of a wall is printed in, given its deepest inset: inside out for Inner/Outer, outside in for
+// Outer/Inner, and for Inner/Outer/Inner the third wall onwards inside out, then the outer wall, then the first inner
+// wall. Inner/Outer/Inner prints its first layer Inner/Outer, and outside in when there is no third wall.
+std::vector<int> wall_sequence_insets(const std::string &wall_sequence, bool first_layer, int deepest)
+{
+    std::vector<int> insets;
+    if (wall_sequence == "inner wall/outer wall" || (wall_sequence == "inner-outer-inner wall" && first_layer)) {
+        for (int inset = deepest; inset >= 0; -- inset)
+            insets.push_back(inset);
+    } else if (wall_sequence == "outer wall/inner wall" || deepest < 2) {
+        for (int inset = 0; inset <= deepest; ++ inset)
+            insets.push_back(inset);
+    } else {
+        for (int inset = deepest; inset >= 2; -- inset)
+            insets.push_back(inset);
+        insets.push_back(0);
+        insets.push_back(1);
+    }
+    return insets;
+}
+
+// Whether a wall of round_tube() runs with the contour: all but the walls of the hole, and those too when the hole
+// is a thin wall hole, its outer wall touching the contour's with nothing between them.
+bool runs_with_contour(const TubeLoop &loop, bool thin_wall_hole)
+{
+    return loop.side != TubeSide::Hole || thin_wall_hole;
+}
+
+// The insets of the walls on one side of a round_tube() layer, the shared centre line included, in extrusion order.
+std::vector<int> side_insets(const std::vector<TubeLoop> &loops, TubeSide side)
+{
+    std::vector<int> insets;
+    for (const TubeLoop &loop : loops)
+        if (loop.side == side || loop.side == TubeSide::Centre)
+            insets.push_back(loop.inset);
+    return insets;
+}
+
+// The walls of a round_tube() layer in extrusion order, as side and inset: "c0 c1 h0 h1" is the contour's outer wall,
+// then its first inner wall, then the same for the hole, and "m" marks the wall in the middle both sides share.
+std::string wall_order(const std::vector<TubeLoop> &loops)
+{
+    std::string out;
+    for (const TubeLoop &loop : loops)
+        out += std::string(out.empty() ? "" : " ") + (loop.side == TubeSide::Contour ? "c" : loop.side == TubeSide::Hole ? "h" : "m") +
+               std::to_string(loop.inset);
+    return out;
+}
+
+} // namespace
+
+// Each side of a tube wall prints its walls in the order the wall sequence asks for, from two walls a side up to
+// four. The inner wall Arachne lays in the middle of a wall too narrow for a pair of them is an inner wall of both
+// sides; Classic fills that middle with gap fill instead, so it has one wall less a side there.
+TEST_CASE("Each side of a tube wall prints its walls in the wall sequence order", "[Perimeters]")
+{
+    struct TubeWall {
+        double wall;
+        int    wall_loops;
+        // Walls a side, a shared inner wall included.
+        int    arachne_walls;
+        int    classic_walls;
+    };
+    const TubeWall tube = GENERATE(values<TubeWall>({
+        { 1.5, 3, 2, 1 }, { 2.0, 2, 2, 2 }, { 2.5, 3, 3, 2 }, { 3.0, 3, 3, 3 }, { 4.0, 4, 4, 4 } }));
+    const char       *wall_generator = GENERATE("classic", "arachne");
+    const std::string wall_sequence  = GENERATE("inner wall/outer wall", "outer wall/inner wall", "inner-outer-inner wall");
+    CAPTURE(tube.wall, tube.wall_loops, wall_generator, wall_sequence);
+
+    DynamicPrintConfig config = tube_config(wall_generator, tube.wall_loops);
+    config.set_deserialize_strict("wall_sequence", wall_sequence);
+    Print print;
+    Model model;
+    round_tube(print, model, config, tube.wall);
+    const std::vector<std::vector<TubeLoop>> layers = tube_loops(print, tube.wall);
+    // 2mm at 0.2mm layers.
+    REQUIRE(layers.size() == 10);
+
+    const int walls = std::string(wall_generator) == "arachne" ? tube.arachne_walls : tube.classic_walls;
+    for (size_t i = 0; i < layers.size(); ++ i) {
+        for (const TubeSide side : { TubeSide::Contour, TubeSide::Hole }) {
+            const bool contour_side = side == TubeSide::Contour;
+            CAPTURE(i, contour_side);
+            const std::vector<int> insets = side_insets(layers[i], side);
+            REQUIRE(int(insets.size()) == walls);
+            CHECK(insets == wall_sequence_insets(wall_sequence, i == 0, walls - 1));
+        }
+    }
+}
+
+// The outer wall of a thin wall hole touches the contour's with nothing between them. The hole is printed first, so
+// the contour leans on it, unless the wall sequence puts the outer walls first.
+TEST_CASE("A thin wall hole is printed before the contour unless the outer walls go first", "[Perimeters]")
+{
+    const char       *wall_generator = GENERATE("classic", "arachne");
+    const std::string wall_sequence  = GENERATE("inner wall/outer wall", "outer wall/inner wall", "inner-outer-inner wall");
+    CAPTURE(wall_generator, wall_sequence);
+
+    DynamicPrintConfig config = tube_config(wall_generator, 3);
+    config.set_deserialize_strict("wall_sequence", wall_sequence);
+    Print print;
+    Model model;
+    round_tube(print, model, config, 1.);
+    const std::vector<std::vector<TubeLoop>> layers = tube_loops(print, 1.);
+    REQUIRE(layers.size() == 10);
+
+    const TubeSide first = wall_sequence == "outer wall/inner wall" ? TubeSide::Contour : TubeSide::Hole;
+    for (size_t i = 0; i < layers.size(); ++ i) {
+        CAPTURE(i);
+        REQUIRE(layers[i].size() == 2);
+        REQUIRE(layers[i][0].side != layers[i][1].side);
+        CHECK(layers[i].front().side == first);
+    }
+}
+
+// A 1.5mm tube wall leaves Inner/Outer/Inner no third wall to sandwich, only the inner wall Arachne lays in the middle
+// for both sides, or Classic's gap fill. Past the first layer it prints the hole first, then the contour, then the
+// middle.
+TEST_CASE("Inner/Outer/Inner prints the hole of a narrow tube wall first and the middle last", "[Perimeters]")
+{
+    const char *wall_generator = GENERATE("classic", "arachne");
+    CAPTURE(wall_generator);
+
+    DynamicPrintConfig config = tube_config(wall_generator, 3);
+    config.set_deserialize_strict("wall_sequence", "inner-outer-inner wall");
+    Print print;
+    Model model;
+    round_tube(print, model, config, 1.5);
+    const std::vector<std::vector<TubeLoop>> layers = tube_loops(print, 1.5);
+    REQUIRE(layers.size() == 10);
+
+    // Classic's gap fill is not a wall loop, and goes after the walls.
+    const std::string expected = std::string(wall_generator) == "arachne" ? "h0 c0 m1" : "h0 c0";
+    for (size_t i = 1; i < layers.size(); ++ i) {
+        CAPTURE(i);
+        CHECK(wall_order(layers[i]) == expected);
+    }
+}
+
+// The contour's walls run in the wall direction and the hole's against it, except that the walls of a thin wall
+// hole run with the contour, as does the inner wall Arachne shares between both sides of a 1.5mm tube wall.
+TEST_CASE("Tube walls run in the wall direction and hole walls against it", "[Perimeters]")
+{
+    const double      wall           = GENERATE(1.0, 1.5, 2.0, 3.0);
+    const char       *wall_generator = GENERATE("classic", "arachne");
+    const std::string wall_direction = GENERATE("ccw", "cw");
+    CAPTURE(wall, wall_generator, wall_direction);
+
+    DynamicPrintConfig config = tube_config(wall_generator, 3);
+    config.set_deserialize_strict("wall_direction", wall_direction);
+    Print print;
+    Model model;
+    round_tube(print, model, config, wall);
+    const std::vector<std::vector<TubeLoop>> layers = tube_loops(print, wall);
+    REQUIRE(layers.size() == 10);
+
+    const bool thin_wall_hole = wall == 1.;
+    for (size_t i = 0; i < layers.size(); ++ i) {
+        CAPTURE(i);
+        REQUIRE(std::any_of(layers[i].begin(), layers[i].end(), [](const TubeLoop &loop) { return loop.side == TubeSide::Contour; }));
+        REQUIRE(std::any_of(layers[i].begin(), layers[i].end(), [](const TubeLoop &loop) { return loop.side == TubeSide::Hole; }));
+        for (const TubeLoop &loop : layers[i]) {
+            CAPTURE(int(loop.side), loop.inset);
+            CHECK(loop.ccw == (runs_with_contour(loop, thin_wall_hole) == (wall_direction == "ccw")));
+        }
+    }
+}
+
+// Reverse on even with no threshold reverses every wall of every other layer, or only the inner walls when it is
+// restricted to them, and leaves the order of the walls alone.
+TEST_CASE("Reverse on even reverses the tube walls of every other layer", "[Perimeters]")
+{
+    const double wall                  = GENERATE(1.0, 1.5, 3.0);
+    const char  *wall_generator        = GENERATE("classic", "arachne");
+    const bool   reverse_internal_only = GENERATE(false, true);
+    CAPTURE(wall, wall_generator, reverse_internal_only);
+
+    auto slice = [&](bool overhang_reverse) {
+        DynamicPrintConfig config = tube_config(wall_generator, 3);
+        config.set_deserialize_strict({
+            { "overhang_reverse",               overhang_reverse },
+            { "overhang_reverse_internal_only", reverse_internal_only },
+        });
+        Print print;
+        Model model;
+        round_tube(print, model, config, wall);
+        return tube_loops(print, wall);
+    };
+    const std::vector<std::vector<TubeLoop>> plain    = slice(false);
+    const std::vector<std::vector<TubeLoop>> reversed = slice(true);
+    REQUIRE(plain.size() == 10);
+    REQUIRE(reversed.size() == plain.size());
+
+    for (size_t i = 0; i < plain.size(); ++ i) {
+        CAPTURE(i);
+        REQUIRE(reversed[i].size() == plain[i].size());
+        for (size_t j = 0; j < plain[i].size(); ++ j) {
+            CAPTURE(j);
+            CHECK(reversed[i][j].side == plain[i][j].side);
+            CHECK(reversed[i][j].inset == plain[i][j].inset);
+            const bool flips = i % 2 == 1 && (! reverse_internal_only || plain[i][j].inset > 0);
+            CHECK(reversed[i][j].ccw == (plain[i][j].ccw != flips));
+        }
+    }
+}
+
+namespace {
+
+DynamicPrintConfig brim_tube_config(const char *wall_generator, const std::string &wall_sequence, const char *brim_type, double brim_width)
+{
+    DynamicPrintConfig config = tube_config(wall_generator, 3);
+    config.set_deserialize_strict({
+        { "wall_sequence", wall_sequence },
+        { "brim_type",     brim_type },
+        { "brim_width",    brim_width },
+    });
+    return config;
+}
+
+} // namespace
+
+// A brim against the outer walls makes the first layer print them first, whatever the wall sequence, so the brim runs
+// straight on into the outer wall: each side of the tube wall outside in, and the contour before a thin wall hole.
+// Brims that may leave the outer walls bare keep the wall sequence, and so do the layers above.
+TEST_CASE("A brim against the outer walls makes the first layer print them first", "[Perimeters]")
+{
+    struct Brim {
+        const char *type;
+        double      width;
+        bool        outer_walls_first;
+    };
+    const Brim brim = GENERATE(values<Brim>({
+        { "no_brim", 5., false }, { "inner_only", 5., false }, { "auto_brim", 5., false }, { "outer_only", 0., false },
+        { "outer_only", 5., true }, { "outer_and_inner", 5., true }, { "leading_edge_only", 5., true } }));
+    const double      wall           = GENERATE(1.0, 3.0);
+    const char       *wall_generator = GENERATE("classic", "arachne");
+    const std::string wall_sequence  = GENERATE("inner wall/outer wall", "inner-outer-inner wall");
+    CAPTURE(brim.type, brim.width, wall, wall_generator, wall_sequence);
+
+    Print print;
+    Model model;
+    round_tube(print, model, brim_tube_config(wall_generator, wall_sequence, brim.type, brim.width), wall);
+    const std::vector<std::vector<TubeLoop>> layers = tube_loops(print, wall);
+    REQUIRE(layers.size() == 10);
+
+    // The thin wall hole has its outer wall a side, the 3mm tube wall three walls a side.
+    const size_t walls = wall == 1. ? 1 : 3;
+    for (const size_t i : { size_t(0), size_t(1) }) {
+        const bool outer_walls_first = brim.outer_walls_first && i == 0;
+        for (const TubeSide side : { TubeSide::Contour, TubeSide::Hole }) {
+            const bool contour_side = side == TubeSide::Contour;
+            CAPTURE(i, contour_side);
+            const std::vector<int> insets = side_insets(layers[i], side);
+            REQUIRE(insets.size() == walls);
+            CHECK(insets == wall_sequence_insets(outer_walls_first ? "outer wall/inner wall" : wall_sequence, i == 0, int(walls) - 1));
+        }
+        if (wall == 1.)
+            CHECK(layers[i].front().side == (outer_walls_first ? TubeSide::Contour : TubeSide::Hole));
+    }
+}
+
+// Changing the brim of a sliced print regenerates the walls when the first layer's wall order changes with it, so
+// the print gets the walls a slice from scratch with the new brim gets.
+TEST_CASE("Changing the brim updates the wall order of the first layer", "[Perimeters]")
+{
+    struct BrimChange {
+        const char *from_type;
+        double      from_width;
+        const char *to_type;
+        double      to_width;
+    };
+    const BrimChange change = GENERATE(values<BrimChange>({
+        { "outer_only", 0., "outer_only", 5. }, { "outer_only", 5., "outer_only", 0. },
+        { "no_brim", 5., "outer_and_inner", 5. }, { "outer_and_inner", 5., "inner_only", 5. } }));
+    const char *wall_generator = GENERATE("classic", "arachne");
+    CAPTURE(change.from_type, change.from_width, change.to_type, change.to_width, wall_generator);
+
+    const std::string wall_sequence = "inner wall/outer wall";
+    Print print;
+    Model model;
+    round_tube(print, model, brim_tube_config(wall_generator, wall_sequence, change.from_type, change.from_width), 3.);
+    const std::string before = wall_order(tube_loops(print, 3.).front());
+    print.apply(model, brim_tube_config(wall_generator, wall_sequence, change.to_type, change.to_width));
+    print.process();
+    const std::string after = wall_order(tube_loops(print, 3.).front());
+
+    Print fresh_print;
+    Model fresh_model;
+    round_tube(fresh_print, fresh_model, brim_tube_config(wall_generator, wall_sequence, change.to_type, change.to_width), 3.);
+    const std::string fresh = wall_order(tube_loops(fresh_print, 3.).front());
+
+    // The change does turn the first layer around.
+    REQUIRE(before != fresh);
+    CHECK(after == fresh);
+}

tests/fff_print/test_print.cpp

@@ -735,6 +735,65 @@ TEST_CASE("Custom G-code placeholders are substituted", "[Print]")
     CHECK(per_layer.find(";Layer:399 ") != std::string::npos);
 }
 
+// The final print statistics are known only after the whole G-code is generated, yet every custom G-code,
+// the file header included, gets the same values as filename_format.
+TEST_CASE("Print statistics in custom G-code match the final print statistics", "[Print][Regression]")
+{
+    const std::string gcode_key = GENERATE(as<std::string>{}, "file_start_gcode", "machine_start_gcode", "machine_end_gcode");
+    // Bambu printers use another tag table and G-code layout.
+    const bool is_bbl = GENERATE(false, true);
+    CAPTURE(gcode_key, is_bbl);
+
+    const std::vector<std::string> number_keys = { "total_weight", "used_filament", "total_cost", "total_wipe_tower_cost",
+                                                   "total_wipe_tower_filament" };
+    const std::vector<std::string> time_keys   = { "print_time", "normal_print_time", "silent_print_time" };
+    std::string                    templ;
+    for (const std::vector<std::string> *keys : { &number_keys, &time_keys })
+        for (const std::string &key : *keys)
+            templ += "; stat " + key + "={" + key + "}\n";
+
+    DynamicPrintConfig config = DynamicPrintConfig::full_print_config();
+    config.set_deserialize_strict({
+        { gcode_key,          templ },
+        { "filament_density", "1.25" },
+        { "filament_cost",    "20" },
+        { "time_cost",        "2" },
+    });
+    Print print;
+    Model model;
+    init_print({ cube(20) }, print, model, config);
+    print.is_BBL_printer() = is_bbl;
+
+    std::string gcode;
+    REQUIRE_NOTHROW(gcode = Slic3r::Test::gcode(print));
+
+    // Match whole lines only: the config block repeats the template on a single line, and Bambu printers
+    // write that block before the start G-code.
+    const std::string lines    = "\n" + gcode;
+    const auto        value_of = [&lines](const std::string &key) {
+        const std::string prefix = "\n; stat " + key + "=";
+        const size_t      start  = lines.find(prefix);
+        REQUIRE(start != std::string::npos);
+        const size_t begin = start + prefix.size();
+        return lines.substr(begin, lines.find('\n', begin) - begin);
+    };
+    // The same statistics filename_format is expanded with.
+    DynamicConfig stats = print.print_statistics().config();
+    // A 20mm cube with filament_density 1.25 weighs something, unlike the running extruded_weight_total in the header.
+    CHECK(stats.opt_float("total_weight") > 0.);
+    for (const std::string &key : number_keys) {
+        CAPTURE(key);
+        const std::string value = value_of(key);
+        REQUIRE(value.find('@') == std::string::npos);
+        // Written with two decimals.
+        CHECK_THAT(std::stod(value), Catch::Matchers::WithinAbs(stats.opt_float(key), 0.006));
+    }
+    for (const std::string &key : time_keys) {
+        CAPTURE(key);
+        CHECK(value_of(key) == stats.opt_string(key));
+    }
+}
+
 TEST_CASE("export_gcode writes G-code without a result pointer", "[Print][export_gcode]")
 {
     Print print;

tests/libslic3r/test_preset_bundle_loading.cpp

@@ -985,6 +985,37 @@ TEST_CASE("A user filament synced to the cloud and back keeps its values and uns
     }
 }
 
+TEST_CASE("A project filament storing one value for a per-variant key applies it to every variant", "[Preset][Bundle][Regression]")
+{
+    PresetCollection filaments(Preset::TYPE_FILAMENT, Preset::filament_options(),
+                               static_cast<const PrintRegionConfig &>(FullPrintConfig::defaults()));
+    Preset &parent = add_inmemory_preset(filaments, "Parent Filament");
+    parent.config.set_key_value("filament_extruder_variant", new ConfigOptionStrings({"Direct Drive Standard", "Direct Drive High Flow"}));
+    parent.config.set_key_value("adaptive_pressure_advance_model", new ConfigOptionStrings({"parent standard", "parent high flow"}));
+    parent.config.set_deserialize_strict("pressure_advance", "0.02,0.03");
+    parent.is_system = true;
+
+    // A filament saved before these keys became per-variant lists both variants but stores each key once.
+    const std::string model = "0.025,15.6,5000";
+    DynamicPrintConfig config;
+    config.set_key_value(BBL_JSON_KEY_INHERITS, new ConfigOptionString("Parent Filament"));
+    config.set_key_value("filament_extruder_variant", new ConfigOptionStrings({"Direct Drive Standard", "Direct Drive High Flow"}));
+    config.set_key_value("adaptive_pressure_advance_model", new ConfigOptionStrings({model}));
+    config.set_deserialize_strict("pressure_advance", "0.016");
+    auto embedded                 = std::make_unique<Preset>(Preset::TYPE_FILAMENT, "Project Filament", false);
+    embedded->config              = std::move(config);
+    embedded->is_project_embedded = true;
+
+    std::vector<Preset *>      project_presets{embedded.get()};
+    PresetsConfigSubstitutions substitutions;
+    filaments.load_project_embedded_presets(project_presets, PRESET_FILAMENT_NAME, substitutions, ForwardCompatibilitySubstitutionRule::Disable);
+
+    const Preset *loaded = filaments.find_preset("Project Filament");
+    REQUIRE(loaded != nullptr);
+    CHECK(loaded->config.option<ConfigOptionStrings>("adaptive_pressure_advance_model")->values == std::vector<std::string>{model, model});
+    check_double_vector(loaded->config.option<ConfigOptionFloats>("pressure_advance")->values, {0.016, 0.016});
+}
+
 TEST_CASE("Repeated loads of a user preset directory produce the same presets", "[Preset][Bundle]")
 {
     ScopedTemporaryDir temp_dir;

tests/slic3rutils/CMakeLists.txt

@@ -6,7 +6,7 @@ add_executable(${_TEST_NAME}_tests
     test_creality_cfs_match.cpp
     test_dev_mapping.cpp
     test_device_access.cpp
-    test_moonraker_discovery.cpp
+    test_moonraker_printer_agent.cpp
     test_network_discovery.cpp
     test_filament_bitmap_utils.cpp
     test_colour_picker_field.cpp
@@ -30,6 +30,7 @@ add_executable(${_TEST_NAME}_tests
     test_plugin_capabilities_in_use.cpp
     test_plugin_status.cpp
     test_printer_agent.cpp
+    test_qidi_printer_agent.cpp
     test_plugin_install.cpp
     test_plugin_lifecycle.cpp
     test_plugin_resource_texture.cpp

tests/slic3rutils/test_imgui_wrapper.cpp

@@ -1,6 +1,7 @@
-// How ImGuiWrapper turns wx mouse events into ImGui input. ImGuiWrapper lives in libslic3r_gui; this is
+// How ImGuiWrapper turns wx mouse events into ImGui input, and when it reports that ImGui owns a key.
-// the suite that links it. Same Windows include prologue as test_texture_color_palette.cpp (wx pulls in
+// ImGuiWrapper lives in libslic3r_gui; this is the suite that links it. Same Windows include prologue
-// <windows.h>; keep WIN32_LEAN_AND_MEAN / NOMINMAX ahead of it).
+// as test_texture_color_palette.cpp (wx pulls in <windows.h>; keep WIN32_LEAN_AND_MEAN / NOMINMAX
+// ahead of it).
 #ifdef WIN32
     #ifndef WIN32_LEAN_AND_MEAN
         #define WIN32_LEAN_AND_MEAN
@@ -17,12 +18,15 @@
 #include <catch2/matchers/catch_matchers_floating_point.hpp>
 
 #include <imgui/imgui.h>
+#include <imgui/imgui_internal.h>
 #include <wx/event.h>
 
 #include "slic3r/GUI/ImGuiWrapper.hpp"
+#include "slic3r/GUI/KeyChord.hpp"
 
 using Catch::Matchers::WithinAbs;
 using Slic3r::GUI::ImGuiWrapper;
+using Slic3r::GUI::KeyChord;
 
 namespace {
 
@@ -41,6 +45,45 @@ float wheel_after(int rotation, wxMouseWheelAxis axis)
     return ImGui::GetIO().MouseWheel;
 }
 
+// Runs ImGui frames without OpenGL by building the font atlas on the CPU.
+struct ImGuiFrames
+{
+    ImGuiWrapper imgui;
+
+    ImGuiFrames()
+    {
+        imgui.set_display_size(800.f, 600.f);
+        unsigned char* pixels = nullptr;
+        int            width = 0, height = 0;
+        ImGui::GetIO().Fonts->GetTexDataAsRGBA32(&pixels, &width, &height);
+    }
+
+    template<class Draw> void frame(Draw draw)
+    {
+        ImGui::NewFrame();
+        draw();
+        ImGui::EndFrame();
+    }
+
+    // SetKeyboardFocusHere() activates the field in the next frame that draws it.
+    void draw_input(bool focus)
+    {
+        ImGui::Begin("window");
+        if (focus)
+            ImGui::SetKeyboardFocusHere();
+        ImGui::InputText("##text", text, sizeof(text));
+        ImGui::End();
+    }
+
+    char text[16] = "";
+};
+
+void draw_modal()
+{
+    if (ImGui::BeginPopupModal("modal"))
+        ImGui::EndPopup();
+}
+
 } // namespace
 
 TEST_CASE("a vertical wheel event steps ImGui's wheel in its own direction", "[ImGuiWrapper]")
@@ -59,3 +102,62 @@ TEST_CASE("a wheel event with no rotation or on the horizontal axis does not ste
     }));
     CHECK_THAT(wheel_after(rotation, axis), WithinAbs(0.0, 0.0));
 }
+
+TEST_CASE("an InputText counts as active only while it holds the keyboard", "[ImGuiWrapper]")
+{
+    ImGuiFrames f;
+    f.frame([&] { f.draw_input(false); });
+    CHECK_FALSE(f.imgui.text_input_active());
+
+    f.frame([&] { f.draw_input(true); });
+    f.frame([&] { f.draw_input(false); });
+    CHECK(f.imgui.text_input_active());
+
+    f.frame([] {});
+    f.frame([] {});
+    CHECK_FALSE(f.imgui.text_input_active());
+}
+
+TEST_CASE("a modal counts as open from its first frame until a frame no longer draws it", "[ImGuiWrapper]")
+{
+    ImGuiFrames f;
+    CHECK_FALSE(f.imgui.modal_popup_open());
+
+    f.frame([] {
+        ImGui::OpenPopup("modal");
+        draw_modal();
+    });
+    CHECK(f.imgui.modal_popup_open());
+
+    // A frame opened by input, before anything is drawn in it.
+    ImGui::NewFrame();
+    CHECK(f.imgui.modal_popup_open());
+    draw_modal();
+    ImGui::EndFrame();
+    CHECK(f.imgui.modal_popup_open());
+
+    // A frame that no longer draws it, as when its canvas is hidden.
+    f.frame([] {});
+    REQUIRE(ImGui::GetTopMostPopupModal() != nullptr);
+    CHECK_FALSE(f.imgui.modal_popup_open());
+}
+
+TEST_CASE("ImGui owns every key under a modal and text-editing keys in an active InputText", "[ImGuiWrapper]")
+{
+    ImGuiFrames    f;
+    const KeyChord letter{ 'A' };
+    const KeyChord save{ 'S', wxMOD_CONTROL };
+    CHECK_FALSE(f.imgui.owns_key(letter));
+    CHECK_FALSE(f.imgui.owns_key(save));
+
+    f.frame([&] { f.draw_input(true); });
+    f.frame([&] { f.draw_input(false); });
+    CHECK(f.imgui.owns_key(letter));
+    CHECK_FALSE(f.imgui.owns_key(save));
+
+    f.frame([] {
+        ImGui::OpenPopup("modal");
+        draw_modal();
+    });
+    CHECK(f.imgui.owns_key(save));
+}

tests/slic3rutils/test_moonraker_discovery.cpp

@@ -1,51 +0,0 @@
-#include <catch2/catch_test_macros.hpp>
-
-#include <string>
-#include "slic3r/Utils/MoonrakerPrinterAgent.hpp"
-
-using namespace Slic3r;
-
-namespace {
-
-class DiscoveryAgent : public MoonrakerPrinterAgent
-{
-public:
-    using MoonrakerPrinterAgent::MoonrakerPrinterAgent;
-    using MoonrakerPrinterAgent::device_info;
-    mutable unsigned fetch_count = 0;
-
-protected:
-    bool fetch_device_info(const std::string&, const std::string&, MoonrakerDeviceInfo& info, std::string&) const override
-    {
-        ++fetch_count;
-        info.dev_name = "Test printer";
-        return true;
-    }
-};
-
-} // namespace
-
-TEST_CASE("Moonraker discovery waits for a complete device identity", "[MoonrakerDiscovery]")
-{
-    DiscoveryAgent agent("");
-    unsigned announcements = 0;
-    nlohmann::json announcement;
-    agent.set_on_ssdp_msg_fn([&](std::string payload) {
-        ++announcements;
-        announcement = nlohmann::json::parse(payload);
-    });
-
-    agent.start_discovery(true, false);
-    REQUIRE(announcements == 0);
-    REQUIRE(agent.fetch_count == 0);
-
-    agent.device_info.dev_id = "127.0.0.1:7125";
-    agent.device_info.dev_ip = agent.device_info.dev_id;
-    agent.device_info.base_url = "http://127.0.0.1:7125";
-    agent.start_discovery(true, false);
-    REQUIRE(announcements == 1);
-    REQUIRE(agent.fetch_count == 1);
-    REQUIRE(announcement.at("dev_id") == agent.device_info.dev_id);
-    REQUIRE(announcement.at("dev_ip") == agent.device_info.dev_ip);
-    REQUIRE(announcement.at("dev_name") == "Test printer");
-}

tests/slic3rutils/test_moonraker_printer_agent.cpp

@@ -0,0 +1,636 @@
+#include <catch2/catch_message.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/generators/catch_generators.hpp>
+
+#include <atomic>
+#include <chrono>
+#include <condition_variable>
+#include <cstddef>
+#include <functional>
+#include <future>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <utility>
+#include <vector>
+
+#include <boost/asio/buffer.hpp>
+#include <boost/asio/io_context.hpp>
+#include <boost/asio/ip/address.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/beast/core/error.hpp>
+#include <boost/beast/core/flat_buffer.hpp>
+#include <boost/beast/http/message.hpp>
+#include <boost/beast/http/read.hpp>
+#include <boost/beast/http/status.hpp>
+#include <boost/beast/http/string_body.hpp>
+#include <boost/beast/http/write.hpp>
+#include <boost/beast/websocket/error.hpp>
+#include <boost/beast/websocket/rfc6455.hpp>
+#include <boost/beast/websocket/stream.hpp>
+#include <nlohmann/json.hpp>
+
+#include "slic3r/Utils/IPrinterAgent.hpp"
+#include "slic3r/Utils/MoonrakerPrinterAgent.hpp"
+
+using namespace Slic3r;
+
+namespace {
+
+namespace beast     = boost::beast;
+namespace http      = beast::http;
+namespace websocket = beast::websocket;
+namespace net       = boost::asio;
+using tcp           = net::ip::tcp;
+using namespace std::chrono_literals;
+
+class DiscoveryAgent : public MoonrakerPrinterAgent
+{
+public:
+    using MoonrakerPrinterAgent::MoonrakerPrinterAgent;
+    using MoonrakerPrinterAgent::device_info;
+    mutable unsigned fetch_count = 0;
+
+protected:
+    bool fetch_device_info(const ConnectionSettings&, MoonrakerDeviceInfo& info, std::string&) const override
+    {
+        ++fetch_count;
+        info.dev_name = "Test printer";
+        return true;
+    }
+};
+
+class StreamAgent : public MoonrakerPrinterAgent
+{
+public:
+    using MoonrakerPrinterAgent::MoonrakerPrinterAgent;
+    using MoonrakerPrinterAgent::ws_timings;
+
+    // Starts the stream the way a connection does, from a snapshot of the connection settings.
+    void start_stream(const std::string& base_url, bool use_ssl = false)
+    {
+        const std::string dev_id = "printer";
+        ConnectionSettings connection;
+        connection.dev_id   = dev_id;
+        connection.base_url = base_url;
+        connection.use_ssl  = use_ssl;
+        start_status_stream(dev_id, std::move(connection));
+    }
+
+    void stop_stream() { stop_status_stream(); }
+
+protected:
+    bool init_device_info(const PrinterConnectionParams& params) override
+    {
+        device_info          = MoonrakerDeviceInfo{};
+        device_info.dev_id   = params.dev_id;
+        device_info.dev_ip   = params.host;
+        device_info.base_url = std::string(params.use_ssl ? "https://" : "http://") + params.host + ":" + params.port;
+        return true;
+    }
+
+    bool fetch_device_info(const ConnectionSettings&, MoonrakerDeviceInfo& info, std::string&) const override
+    {
+        info.dev_name = "Test printer";
+        return true;
+    }
+};
+
+enum class Behavior {
+    SilentBeforeHandshake,     // Accepts the connection and never answers
+    Silent,                    // Completes the upgrade, then never reads or sends
+    AnswersPings,              // Reports a status, then answers pings and sends nothing else
+    AnswersPingsWithoutStatus, // Answers pings but never reports a status
+    Chatters,                  // Reports a status, then answers pings and sends notifications that carry no status
+    HangsUp,                   // Reports a status, then closes the websocket
+    HangsUpWithoutAnswer,      // Closes the websocket without sending anything
+    IgnoresClose,              // Reports Klippy disconnected, then never answers the close
+    StallsObjectList,          // Never answers the stream's object list request
+    StallsStatusQuery,         // Never answers HTTP requests until released, then hangs up on them
+    RejectsTls,                // Records the first byte of the stream, which a TLS client sends as a handshake
+};
+
+class FakePrinter
+{
+public:
+    explicit FakePrinter(Behavior behavior) : m_behavior(behavior)
+    {
+        m_accept_thread = std::thread([this] { accept_loop(); });
+    }
+
+    ~FakePrinter()
+    {
+        release();
+        m_stopping = true;
+        // Wakes the blocking accept.
+        tcp::socket wake{m_accept_ioc};
+        beast::error_code ec;
+        wake.connect(m_acceptor.local_endpoint(), ec);
+        m_accept_thread.join();
+        for (std::thread& connection : m_connections)
+            connection.join();
+    }
+
+    std::string host() const { return "127.0.0.1"; }
+    std::string port() const { return std::to_string(m_acceptor.local_endpoint().port()); }
+    std::string base_url() const { return "http://" + host() + ":" + port(); }
+
+    // A connection is ready once it reaches the state its behavior waits in.
+    bool wait_for_ready_connections(int count, std::chrono::milliseconds timeout = 10s)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, timeout, [&] { return m_ready >= count; });
+    }
+
+    bool wait_for_http_requests(int count)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, 10s, [&] { return m_http_requests >= count; });
+    }
+
+    // Waits until the printer, once released, has hung up on `count` stalled HTTP requests.
+    bool wait_for_http_hang_ups(int count)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, 10s, [&] { return m_http_hung_up >= count; });
+    }
+
+    int close_frames()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_close_frames;
+    }
+
+    // First byte the stream sent, or -1 until it has sent one.
+    bool wait_for_first_byte()
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, 10s, [&] { return m_first_byte >= 0; });
+    }
+
+    int first_byte()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_first_byte;
+    }
+
+    // Hangs up every connection that is waiting.
+    void release()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_released = true;
+        m_changed.notify_all();
+    }
+
+private:
+    void accept_loop()
+    {
+        for (;;) {
+            // Each connection gets its own io_context, so a connection that runs one never runs another's handlers.
+            auto ioc = std::make_unique<net::io_context>();
+            tcp::socket socket{*ioc};
+            beast::error_code ec;
+            m_acceptor.accept(socket, ec);
+            if (ec || m_stopping)
+                return;
+            m_connections.emplace_back(
+                [this, ioc = std::move(ioc), socket = std::move(socket)]() mutable { serve(*ioc, std::move(socket)); });
+        }
+    }
+
+    void serve(net::io_context& ioc, tcp::socket socket)
+    {
+        if (m_behavior == Behavior::SilentBeforeHandshake) {
+            mark_ready();
+            wait_for_release();
+            return;
+        }
+
+        if (m_behavior == Behavior::RejectsTls) {
+            char              first = 0;
+            beast::error_code ec;
+            socket.read_some(net::buffer(&first, 1), ec);
+            if (!ec) {
+                std::lock_guard<std::mutex> lock(m_mutex);
+                m_first_byte = static_cast<unsigned char>(first);
+                m_changed.notify_all();
+            }
+            mark_ready();
+            wait_for_release();
+            return;
+        }
+
+        beast::flat_buffer buffer;
+        http::request<http::string_body> request;
+        beast::error_code ec;
+        http::read(socket, buffer, request, ec);
+        if (ec)
+            return;
+        // The agent also queries the printer's status and object list over plain HTTP.
+        if (!websocket::is_upgrade(request)) {
+            serve_http(socket, request);
+            return;
+        }
+
+        websocket::stream<tcp::socket> ws{std::move(socket)};
+        ws.accept(request, ec);
+        // Without its object list the stream never sends the subscribe request.
+        const int requests = m_behavior == Behavior::StallsObjectList ? 1 : 2;
+        for (int i = 0; i < requests && !ec; ++i) {
+            beast::flat_buffer message;
+            ws.read(message, ec);
+        }
+        if (!ec && (m_behavior == Behavior::AnswersPings || m_behavior == Behavior::Chatters || m_behavior == Behavior::HangsUp)) {
+            const std::string status =
+                nlohmann::json{{"jsonrpc", "2.0"}, {"id", 1}, {"result", {{"status", {{"print_stats", {{"state", "standby"}}}}}}}}.dump();
+            ws.write(net::buffer(status), ec);
+        }
+        if (ec)
+            return;
+
+        switch (m_behavior) {
+        case Behavior::AnswersPings:
+        case Behavior::AnswersPingsWithoutStatus:
+        case Behavior::Chatters:
+            mark_ready();
+            answer_pings(ioc, ws, m_behavior == Behavior::Chatters);
+            break;
+        case Behavior::HangsUp:
+        case Behavior::HangsUpWithoutAnswer:
+            ws.close(websocket::close_code::normal, ec);
+            mark_ready();
+            break;
+        case Behavior::IgnoresClose: {
+            const std::string notification = nlohmann::json{{"jsonrpc", "2.0"}, {"method", "notify_klippy_disconnected"}}.dump();
+            ws.write(net::buffer(notification), ec);
+            mark_ready();
+            wait_for_release();
+            break;
+        }
+        case Behavior::StallsObjectList: answer_pings(ioc, ws, false); break;
+        default: mark_ready(); wait_for_release();
+        }
+    }
+
+    void serve_http(tcp::socket& socket, const http::request<http::string_body>& request)
+    {
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            ++m_http_requests;
+            m_changed.notify_all();
+        }
+        if (m_behavior == Behavior::StallsObjectList) {
+            mark_ready();
+            wait_for_release();
+            return;
+        }
+        if (m_behavior == Behavior::StallsStatusQuery) {
+            wait_for_release();
+            beast::error_code ec;
+            socket.close(ec);
+            std::lock_guard<std::mutex> lock(m_mutex);
+            ++m_http_hung_up;
+            m_changed.notify_all();
+            return;
+        }
+        http::response<http::string_body> response{http::status::not_found, request.version()};
+        response.prepare_payload();
+        beast::error_code ec;
+        http::write(socket, response, ec);
+    }
+
+    // Keeps a read pending, which answers pings, until released or closed, and with `chatter` also sends a notification every 50 ms.
+    void answer_pings(net::io_context& ioc, websocket::stream<tcp::socket>& ws, bool chatter)
+    {
+        const std::string notification = nlohmann::json{{"jsonrpc", "2.0"},
+                                                        {"method", "notify_proc_stat_update"},
+                                                        {"params", nlohmann::json::array({nlohmann::json::object()})}}
+                                             .dump();
+        beast::flat_buffer message;
+        bool reading                    = true;
+        bool writing                    = false;
+        std::function<void()> read_next = [&] {
+            ws.async_read(message, [&](beast::error_code ec, std::size_t) {
+                message.clear();
+                if (ec == websocket::error::closed) {
+                    std::lock_guard<std::mutex> lock(m_mutex);
+                    ++m_close_frames;
+                }
+                if (ec)
+                    reading = false;
+                else
+                    read_next();
+            });
+        };
+        read_next();
+
+        auto next_notification = std::chrono::steady_clock::now();
+        while (reading && !wait_for_release(10ms)) {
+            if (chatter && !writing && std::chrono::steady_clock::now() >= next_notification) {
+                writing = true;
+                next_notification += 50ms;
+                ws.async_write(net::buffer(notification), [&](beast::error_code, std::size_t) { writing = false; });
+            }
+            ioc.restart();
+            ioc.run_for(20ms);
+        }
+        beast::error_code ignored;
+        ws.next_layer().close(ignored);
+        while (reading || writing) {
+            ioc.restart();
+            ioc.run_for(20ms);
+        }
+    }
+
+    void mark_ready()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        ++m_ready;
+        m_changed.notify_all();
+    }
+
+    void wait_for_release()
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        m_changed.wait(lock, [this] { return m_released; });
+    }
+
+    bool wait_for_release(std::chrono::milliseconds timeout)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, timeout, [this] { return m_released; });
+    }
+
+    const Behavior m_behavior;
+    net::io_context m_accept_ioc;
+    tcp::acceptor m_acceptor{m_accept_ioc, {net::ip::make_address("127.0.0.1"), 0}};
+    std::atomic<bool> m_stopping{false};
+    std::thread m_accept_thread;
+    std::vector<std::thread> m_connections;
+    std::mutex m_mutex;
+    std::condition_variable m_changed;
+    int m_ready         = 0;
+    int m_http_requests = 0;
+    int m_http_hung_up  = 0;
+    int m_close_frames  = 0;
+    int m_first_byte    = -1;
+    bool m_released     = false;
+};
+
+// Records when the agent dispatches a status report.
+class Reports
+{
+public:
+    void attach(StreamAgent& agent)
+    {
+        agent.set_on_local_message_fn([this](std::string, std::string) {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            m_times.push_back(std::chrono::steady_clock::now());
+            m_changed.notify_all();
+        });
+    }
+
+    bool wait_for(std::size_t count)
+    {
+        std::unique_lock<std::mutex> lock(m_mutex);
+        return m_changed.wait_for(lock, 10s, [&] { return m_times.size() >= count; });
+    }
+
+    std::vector<std::chrono::steady_clock::time_point> times()
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        return m_times;
+    }
+
+private:
+    std::mutex m_mutex;
+    std::condition_variable m_changed;
+    std::vector<std::chrono::steady_clock::time_point> m_times;
+};
+
+// A printer and a stream agent connected to it.
+struct StreamFixture
+{
+    explicit StreamFixture(Behavior behavior) : printer(behavior) {}
+
+    // Runs before the members are destroyed, so the agent's destructor never joins a stream the printer still holds open.
+    ~StreamFixture() { printer.release(); }
+
+    void start() { agent.start_stream(printer.base_url()); }
+
+    // Runs the stream as a wss client; the printer must be served on the same port.
+    void start_secure() { agent.start_stream("https://" + printer.host() + ":" + printer.port(), true); }
+
+    // Stops the stream, giving it `limit` to return before the printer hangs up on it.
+    bool stops_within(std::chrono::milliseconds limit)
+    {
+        auto stopped       = std::async(std::launch::async, [this] { agent.stop_stream(); });
+        const bool in_time = stopped.wait_for(limit) == std::future_status::ready;
+        printer.release();
+        stopped.wait();
+        return in_time;
+    }
+
+    FakePrinter printer;
+    StreamAgent agent{""};
+};
+
+} // namespace
+
+TEST_CASE("Moonraker discovery waits for a complete device identity", "[MoonrakerPrinterAgent][Discovery]")
+{
+    DiscoveryAgent agent("");
+    unsigned announcements = 0;
+    nlohmann::json announcement;
+    agent.set_on_ssdp_msg_fn([&](std::string payload) {
+        ++announcements;
+        announcement = nlohmann::json::parse(payload);
+    });
+
+    agent.start_discovery(true, false);
+    REQUIRE(announcements == 0);
+    REQUIRE(agent.fetch_count == 0);
+
+    agent.device_info.dev_id = "127.0.0.1:7125";
+    agent.device_info.dev_ip = agent.device_info.dev_id;
+    agent.device_info.base_url = "http://127.0.0.1:7125";
+    agent.start_discovery(true, false);
+    REQUIRE(announcements == 1);
+    REQUIRE(agent.fetch_count == 1);
+    REQUIRE(announcement.at("dev_id") == agent.device_info.dev_id);
+    REQUIRE(announcement.at("dev_ip") == agent.device_info.dev_ip);
+    REQUIRE(announcement.at("dev_name") == "Test printer");
+}
+
+TEST_CASE("Stopping the status stream gives a silent printer no more than its timeouts", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    // An open websocket gets the 200 ms close timeout, and a stalled object list request up to 1 s of curl progress to see the stop.
+    const auto [behavior, limit] = GENERATE(table<Behavior, std::chrono::milliseconds>({
+        {Behavior::SilentBeforeHandshake, 500ms},
+        {Behavior::Silent, 1000ms},
+        {Behavior::StallsObjectList, 2000ms},
+    }));
+    CAPTURE(static_cast<int>(behavior));
+
+    StreamFixture f(behavior);
+    f.agent.ws_timings.close = 200ms;
+    f.start();
+    REQUIRE(f.printer.wait_for_ready_connections(1));
+
+    CHECK(f.stops_within(limit));
+}
+
+TEST_CASE("A secure status stream opens with a TLS handshake", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::RejectsTls);
+    f.start_secure();
+    REQUIRE(f.printer.wait_for_first_byte());
+    // 0x16 is a TLS handshake record; a plaintext client would send "GET".
+    CHECK(f.printer.first_byte() == 0x16);
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("Stopping the status stream sends the printer a close frame", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    // A stop while the stream reads, and one while it waits on the object list request.
+    const Behavior behavior = GENERATE(Behavior::AnswersPings, Behavior::StallsObjectList);
+    CAPTURE(static_cast<int>(behavior));
+
+    StreamFixture f(behavior);
+    f.start();
+    REQUIRE(f.printer.wait_for_ready_connections(1));
+
+    CHECK(f.stops_within(3s));
+    CHECK(f.printer.close_frames() == 1);
+}
+
+TEST_CASE("Stopping the status stream does not wait out the reconnect delay", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::HangsUp);
+    f.agent.ws_timings.reconnect_delay = 10s;
+    f.start();
+    REQUIRE(f.printer.wait_for_ready_connections(1));
+    // Lets the stream reach its reconnect wait.
+    std::this_thread::sleep_for(200ms);
+
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("The status stream reconnects when the printer stops answering", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    // An unanswered close ends at whichever of the handshake and close timeouts is shorter.
+    const auto [behavior, handshake, close] = GENERATE(table<Behavior, std::chrono::milliseconds, std::chrono::milliseconds>({
+        {Behavior::Silent, 300ms, 1000ms},
+        {Behavior::IgnoresClose, 300ms, 1000ms},
+        {Behavior::IgnoresClose, 1000ms, 200ms},
+    }));
+    CAPTURE(static_cast<int>(behavior), handshake.count(), close.count());
+
+    StreamFixture f(behavior);
+    f.agent.ws_timings.handshake       = handshake;
+    f.agent.ws_timings.close           = close;
+    f.agent.ws_timings.idle            = 400ms;
+    f.agent.ws_timings.reconnect_delay = 20ms;
+    f.start();
+
+    CHECK(f.printer.wait_for_ready_connections(2));
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("The status stream reconnects at the shortest delay while the printer answers", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::HangsUp);
+    f.agent.ws_timings.reconnect_delay = 50ms;
+    f.start();
+
+    // Twelve 50 ms waits; a backoff that kept doubling would need over 10 s.
+    CHECK(f.printer.wait_for_ready_connections(12, 3s));
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("The status stream keeps retrying a printer that never answers", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::HangsUpWithoutAnswer);
+    f.agent.ws_timings.reconnect_delay = 1ms;
+    f.start();
+
+    // The backoff stops doubling at 32 ms, so 20 attempts take well under the wait.
+    CHECK(f.printer.wait_for_ready_connections(20));
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("A callback on the stream thread can stop the status stream", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    std::promise<void> stopped;
+    std::once_flag stopped_once;
+    StreamFixture f(Behavior::AnswersPings);
+    f.agent.set_on_local_message_fn([&](std::string, std::string) {
+        std::call_once(stopped_once, [&] {
+            f.agent.stop_stream();
+            stopped.set_value();
+        });
+    });
+    f.start();
+
+    REQUIRE(stopped.get_future().wait_for(5s) == std::future_status::ready);
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("A quiet printer that is still up keeps reporting its status", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    Reports reports;
+    StreamFixture f(Behavior::AnswersPings);
+    f.agent.ws_timings.idle      = 400ms;
+    f.agent.ws_timings.heartbeat = 300ms;
+    reports.attach(f.agent);
+    f.start();
+
+    // The status the printer sent, then two heartbeats.
+    REQUIRE(reports.wait_for(3));
+    const auto times = reports.times();
+    // The steady clock is compared in whole milliseconds, so allow 1 ms of rounding.
+    CHECK(times[1] - times[0] >= 299ms);
+    CHECK(times[2] - times[1] >= 299ms);
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("The status stream sends no heartbeat while the printer has nothing new to report", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    const Behavior behavior = GENERATE(Behavior::Chatters, Behavior::AnswersPingsWithoutStatus);
+    CAPTURE(static_cast<int>(behavior));
+
+    Reports reports;
+    StreamFixture f(behavior);
+    f.agent.ws_timings.idle      = 400ms;
+    f.agent.ws_timings.heartbeat = 800ms;
+    reports.attach(f.agent);
+    f.start();
+    REQUIRE(f.printer.wait_for_ready_connections(1));
+
+    // The chattering printer's status, and nothing from the one that never sent a status.
+    const std::size_t expected = behavior == Behavior::Chatters ? 1 : 0;
+    std::this_thread::sleep_for(1500ms);
+    CHECK(reports.times().size() == expected);
+    CHECK(f.stops_within(3s));
+}
+
+TEST_CASE("A disconnect during the connection queries keeps the status stream from starting", "[MoonrakerPrinterAgent][StatusStream]")
+{
+    StreamFixture f(Behavior::StallsStatusQuery);
+    PrinterConnectionParams params;
+    params.dev_id = "printer";
+    params.host   = f.printer.host();
+    params.port   = f.printer.port();
+    f.agent.connect_printer(params);
+    REQUIRE(f.printer.wait_for_http_requests(1));
+
+    // disconnect_printer joins the worker running the stalled query, so it is called aside and the
+    // printer is released to let that query return.
+    auto disconnecting = std::async(std::launch::async, [&] { f.agent.disconnect_printer(); });
+    f.printer.release();
+    // The query has returned once the printer hangs up on it, and a stream would connect right after.
+    REQUIRE(f.printer.wait_for_http_hang_ups(1));
+    CHECK_FALSE(f.printer.wait_for_ready_connections(1, 500ms));
+    disconnecting.wait();
+}

tests/slic3rutils/test_printer_agent.cpp

@@ -1,18 +1,30 @@
 #include <catch2/catch_all.hpp>
 
+#include <functional>
+#include <slic3r/Utils/BBLPrinterAgent.hpp>
+#include <slic3r/Utils/IPrinterAgent.hpp>
+#include <slic3r/Utils/MoonrakerPrinterAgent.hpp>
 #include <memory>
 #include <slic3r/Utils/NetworkAgentFactory.hpp>
 
 #include <catch2/catch_test_macros.hpp>
 #include <pybind11/pytypes.h>
 #include <catch2/catch_message.hpp>
+#include "catch2/matchers/catch_matchers.hpp"
+#include "catch2/matchers/catch_matchers_floating_point.hpp"
 #include "python_test_support.hpp"
 
 #include <pybind11/embed.h>
 #include <pybind11/pybind11.h>
 
+#include <atomic>
+#include <chrono>
+#include <future>
+#include <slic3r/Utils/bambu_networking.hpp>
 #include <string>
+#include <thread>
 #include <pybind11/cast.h>
+#include <utility>
 
 namespace Slic3r { class ICloudServiceAgent; }
 namespace Slic3r { class IPrinterAgent; }
@@ -20,12 +32,390 @@ namespace Slic3r { class IPrinterAgent; }
 using namespace Slic3r;
 namespace py = pybind11;
 
+namespace {
+
+// Releases a promise on scope exit, so a throwing REQUIRE cannot leave a parked detached
+// thread (and any destructor that joins it) blocked forever.
+class ScopedPromiseRelease
+{
+public:
+    explicit ScopedPromiseRelease(std::shared_ptr<std::promise<void>> p) : m_p(std::move(p)) {}
+    ~ScopedPromiseRelease()
+    {
+        if (m_p) {
+            try {
+                m_p->set_value();
+            } catch (...) {
+                // promise already satisfied
+            }
+        }
+    }
+    ScopedPromiseRelease(const ScopedPromiseRelease&) = delete;
+    ScopedPromiseRelease& operator=(const ScopedPromiseRelease&) = delete;
+
+private:
+    std::shared_ptr<std::promise<void>> m_p;
+};
+
+} // namespace
+
+class MoonrakerParserProbe : public MoonrakerPrinterAgent
+{
+public:
+    using MoonrakerPrinterAgent::parse_nozzle_diameter;
+
+    explicit MoonrakerParserProbe(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
+};
+
+TEST_CASE("Moonraker parses nozzle diameter from configfile settings", "[MoonrakerPrinterAgent]")
+{
+    const auto response = nlohmann::json::parse(R"({
+        "result": {
+            "status": {
+                "configfile": {
+                    "settings": {
+                        "extruder": {
+                            "nozzle_diameter": 0.6
+                        }
+                    }
+                }
+            }
+        }
+    })");
+
+    CHECK_THAT(MoonrakerParserProbe::parse_nozzle_diameter(response), Catch::Matchers::WithinAbs(0.6f, 1e-4f));
+}
+
+TEST_CASE("Moonraker parses nozzle diameter from raw config and tolerates missing data", "[MoonrakerPrinterAgent]")
+{
+    const auto raw_config_response = nlohmann::json::parse(R"({
+        "result": {
+            "status": {
+                "configfile": {
+                    "config": {
+                        "extruder": {
+                            "nozzle_diameter": "0.8"
+                        }
+                    }
+                }
+            }
+        }
+    })");
+    const auto missing_response = nlohmann::json::object();
+
+    CHECK_THAT(MoonrakerParserProbe::parse_nozzle_diameter(raw_config_response), Catch::Matchers::WithinAbs(0.8f, 1e-4f));
+    CHECK_THAT(MoonrakerParserProbe::parse_nozzle_diameter(missing_response), Catch::Matchers::WithinAbs(0.0f, 1e-6f));
+}
+
+// why: an agent without a Bambu-dialect translation must refuse these commands before any network or wx path.
+TEST_CASE("default AMS commands report not supported", "[MoonrakerPrinterAgent]")
+{
+    MoonrakerPrinterAgent agent("");
+
+    CHECK(agent.command_ams_refresh_rfid("dev", 123, 1, 0, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    CHECK(agent.command_ams_calibrate("dev", 1, 2, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    CHECK(agent.command_ams_select_tray("dev", "123", 3, false) == ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+}
+
+TEST_CASE("Moonraker light name matching", "[MoonrakerPrinterAgent]")
+{
+    CHECK(moonraker_is_light_name("caselight"));
+    CHECK(moonraker_is_light_name("LED_STRIP"));
+    CHECK_FALSE(moonraker_is_light_name("beeper"));
+    CHECK(moonraker_is_light_name("FLASHLIGHT_SWITCH"));
+    CHECK(moonraker_is_light_name("MODLELIGHT_SWITCH"));
+}
+
+TEST_CASE("Moonraker webcam selection skips disabled webcams and prefers the first enabled one",
+          "[MoonrakerPrinterAgent]")
+{
+    const auto response = nlohmann::json::parse(R"({
+        "result": { "webcams": [
+            { "name": "disabled", "enabled": false, "stream_url": "http://192.168.1.9:8080/stream" },
+            { "name": "enabled",  "enabled": true,  "stream_url": "http://192.168.1.9:8080/stream" }
+        ]}
+    })");
+
+    MoonrakerWebcamSelection selection;
+    REQUIRE(moonraker_parse_webcam_list(response, "http://192.168.1.9:7125", selection));
+    CHECK(selection.name == "enabled");
+    CHECK(selection.url == "http://192.168.1.9:8080/stream");
+    CHECK(selection.mode == CameraStreamMode::http);
+    CHECK(selection.error.empty());
+}
+
+TEST_CASE("Moonraker webcam selection resolves relative URLs, maps rtsp, and rejects other schemes",
+          "[MoonrakerPrinterAgent]")
+{
+    const auto relative = nlohmann::json::parse(R"({
+        "result": { "webcams": [ { "name": "cam", "snapshot_url": "/webcam/?action=snapshot" } ] }
+    })");
+    MoonrakerWebcamSelection rel;
+    REQUIRE(moonraker_parse_webcam_list(relative, "http://192.168.1.9:7125", rel));
+    // Relative URLs use the printer web root, without the Moonraker API port.
+    CHECK(rel.url == "http://192.168.1.9/webcam/?action=snapshot");
+    CHECK(rel.mode == CameraStreamMode::http_snapshot);
+
+    const auto rtsp = nlohmann::json::parse(R"({
+        "result": { "webcams": [ { "name": "cam", "stream_url": "rtsp://192.168.1.9:554/live" } ] }
+    })");
+    MoonrakerWebcamSelection rt;
+    REQUIRE(moonraker_parse_webcam_list(rtsp, "http://192.168.1.9:7125", rt));
+    CHECK(rt.mode == CameraStreamMode::rtsp);
+
+    const auto unsupported = nlohmann::json::parse(R"({
+        "result": { "webcams": [ { "name": "cam", "stream_url": "weird://host/x" } ] }
+    })");
+    MoonrakerWebcamSelection bad;
+    CHECK_FALSE(moonraker_parse_webcam_list(unsupported, "http://192.168.1.9:7125", bad));
+    CHECK(bad.error == "Unsupported webcam URL");
+}
+
+TEST_CASE("Moonraker webcam selection reports no webcam and malformed structure", "[MoonrakerPrinterAgent]")
+{
+    const auto empty = nlohmann::json::parse(R"({ "result": { "webcams": [] } })");
+    MoonrakerWebcamSelection none;
+    CHECK_FALSE(moonraker_parse_webcam_list(empty, "http://host:7125", none));
+    CHECK(none.error == "No enabled webcam");
+
+    const auto disabled_only = nlohmann::json::parse(R"({
+        "result": { "webcams": [ { "name": "disabled", "enabled": false, "stream_url": "http://host/stream" } ] }
+    })");
+    MoonrakerWebcamSelection off;
+    CHECK_FALSE(moonraker_parse_webcam_list(disabled_only, "http://host:7125", off));
+
+    const auto malformed = nlohmann::json::parse(R"({ "result": { "nope": 1 } })");
+    MoonrakerWebcamSelection shape;
+    CHECK_FALSE(moonraker_parse_webcam_list(malformed, "http://host:7125", shape));
+    CHECK(shape.error == "Unexpected JSON structure");
+}
+
+// ===========================================================================
+// UNIT - handle_request's not-supported default.
+// The agent is the only thing that knows what it can translate, so an untranslated
+// command has to say so instead of returning success and letting the UI believe the
+// control worked. Guards the inverse too: the pushing namespace is genuinely
+// satisfied by the websocket status stream, and it re-fires from the keepalive timer
+// roughly once a second, so it must stay a success or it would raise a dialog on a
+// timer. Only branches that touch neither the network nor wx are exercised.
+// ===========================================================================
+TEST_CASE("Moonraker reports untranslated commands as not supported", "[MoonrakerPrinterAgent]")
+{
+    MoonrakerPrinterAgent agent("");
+
+    CHECK(agent.send_message("dev", R"({"print":{"command":"ams_change_filament"}})", 0, 0) ==
+          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    CHECK(agent.send_message("dev", R"({"system":{"command":"set_door_stat"}})", 0, 0) ==
+          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+    CHECK(agent.send_message("dev", R"({"xcam":{"command":"xcam_control_set"}})", 0, 0) ==
+          ORCA_NETWORK_ERR_CMD_NOT_SUPPORTED);
+
+    CHECK(agent.send_message("dev", R"({"pushing":{"command":"pushall"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
+    CHECK(agent.send_message("dev", R"({"pushing":{"command":"start"}})", 0, 0) == BAMBU_NETWORK_SUCCESS);
+
+    // why: malformed input is a different failure than an untranslated command, and the
+    // default must not swallow it into a misleading not-supported verdict.
+    CHECK(agent.send_message("dev", "{not json", 0, 0) == BAMBU_NETWORK_ERR_INVALID_RESULT);
+}
+
+// why: IPrinterAgent::fetch_filament_info is the single virtual hook derived agents override.
+// Pull-mode overrides must be synchronous (the caller reads DevFilaSystem as soon as it
+// returns), but subscription overrides may be fire-and-forget: QidiPrinterAgent/Snapmaker
+// spawn a detached thread when asked for subscription updates. QidiPrinterAgent is `final`,
+// so this probes the subscription contract with a controllable double instead.
+TEST_CASE("a fire-and-forget subscription fetch is not waited on by the caller",
+          "[MoonrakerPrinterAgent]")
+{
+    class RecordingAgent : public Slic3r::MoonrakerPrinterAgent
+    {
+    public:
+        explicit RecordingAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
+
+        // Shared so the detached proxy fetch never touches `this`: a throwing REQUIRE
+        // then cannot leave it dereferencing a destroyed agent.
+        std::shared_ptr<std::atomic<bool>>  invoked{std::make_shared<std::atomic<bool>>(false)};
+        std::shared_ptr<std::promise<void>> release_gate{std::make_shared<std::promise<void>>()};
+        std::shared_ptr<std::promise<void>> done_promise{std::make_shared<std::promise<void>>()};
+
+        bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode sync_mode = FilamentSyncMode::pull) override
+        {
+            // Only the subscription path is allowed to be fire-and-forget.
+            if (sync_mode != FilamentSyncMode::subscription)
+                return true;
+
+            auto invoked_p      = invoked;
+            auto release_gate_p = release_gate;
+            auto done_promise_p = done_promise;
+            std::thread([invoked_p, release_gate_p, done_promise_p]() {
+                invoked_p->store(true);
+                // Block here until the test explicitly releases us, proving the caller
+                // (fetch_filament_info) does not wait for this to run.
+                release_gate_p->get_future().wait();
+                done_promise_p->set_value();
+            }).detach();
+            return true;
+        }
+    };
+
+    auto agent = std::make_shared<RecordingAgent>(std::string{});
+    auto done_future = agent->done_promise->get_future();
+    ScopedPromiseRelease release_gate_guard{agent->release_gate};
+
+    bool immediate_result = agent->fetch_filament_info("test-dev", FilamentSyncMode::subscription);
+
+    // fetch_filament_info must return before its background work completes — prove
+    // it by confirming the background call is still blocked on the gate right now.
+    REQUIRE(immediate_result == true);
+    REQUIRE(done_future.wait_for(std::chrono::milliseconds(100)) == std::future_status::timeout);
+
+    // Now let the background call finish and confirm it actually ran (polymorphic dispatch).
+    agent->release_gate->set_value();
+    REQUIRE(done_future.wait_for(std::chrono::seconds(2)) == std::future_status::ready);
+    REQUIRE(agent->invoked->load() == true);
+}
+
+namespace {
+
+// Globals so a parked proxy fetch thread never dereferences a freed agent.
+std::atomic<int>  g_deferred_fetch_running{0};
+std::atomic<bool> g_deferred_destroy_returned{false};
+
+// Releases the given gates, then joins on scope exit: so a throwing REQUIRE cannot leave
+// the thread blocked (deadlocking the join) or let it std::terminate.
+class ScopedJoiner
+{
+public:
+    ScopedJoiner(std::thread& t, std::shared_ptr<std::promise<void>> gate1, std::shared_ptr<std::promise<void>> gate2)
+        : m_thread(t), m_gates{std::move(gate1), std::move(gate2)}
+    {}
+    ~ScopedJoiner()
+    {
+        for (auto& gate : m_gates) {
+            if (gate) {
+                try {
+                    gate->set_value();
+                } catch (...) {
+                    // promise already satisfied
+                }
+            }
+        }
+        if (m_thread.joinable()) m_thread.join();
+    }
+    ScopedJoiner(const ScopedJoiner&) = delete;
+    ScopedJoiner& operator=(const ScopedJoiner&) = delete;
+
+private:
+    std::thread&                        m_thread;
+    std::shared_ptr<std::promise<void>> m_gates[2];
+};
+
+// A fetch that parks before touching the in-flight counter, so teardown's wait can
+// observe zero first.
+class DeferredFetchAgent : public MoonrakerPrinterAgent
+{
+public:
+    explicit DeferredFetchAgent(std::string log_dir) : MoonrakerPrinterAgent(std::move(log_dir)) {}
+
+    // Shared so a parked proxy fetch can never outlive the stack that owns it.
+    std::shared_ptr<std::promise<void>> entered{std::make_shared<std::promise<void>>()};
+    std::shared_ptr<std::promise<void>> allow_fetch{std::make_shared<std::promise<void>>()};
+    std::shared_ptr<std::promise<void>> allow_finish{std::make_shared<std::promise<void>>()};
+    std::shared_ptr<std::promise<void>> running{std::make_shared<std::promise<void>>()};
+
+    // Runs the callable on the command worker, which teardown joins.
+    void post(std::function<void()> fn) { enqueue_command(std::move(fn)); }
+
+    bool fetch_filament_info(std::string /*dev_id*/, FilamentSyncMode /*sync_mode*/ = FilamentSyncMode::pull) override
+    {
+        // Resumes after ~DeferredFetchAgent destroyed these members; snapshot up front.
+        auto entered_p      = entered;
+        auto allow_fetch_p  = allow_fetch;
+        auto allow_finish_p = allow_finish;
+        auto running_p      = running;
+
+        entered_p->set_value();
+        allow_fetch_p->get_future().wait();
+
+        filament_fetch_in_flight.fetch_add(1, std::memory_order_relaxed);
+        std::thread([this, finish = std::move(allow_finish_p), running = std::move(running_p)] {
+            struct InFlightGuard
+            {
+                MoonrakerPrinterAgent& owner;
+                ~InFlightGuard() { owner.release_fetch_slot(); }
+            } guard{*this};
+
+            g_deferred_fetch_running.fetch_add(1, std::memory_order_relaxed);
+            running->set_value();
+            finish->get_future().wait();
+            g_deferred_fetch_running.fetch_sub(1, std::memory_order_relaxed);
+        }).detach();
+        return true;
+    }
+};
+
+} // namespace
+
+// REGRESSION - teardown must not return while a fetch it started is in flight.
+// The command worker parks a fetch before it reserves the in-flight slot, forcing
+// the "wait already observed zero" interleaving deterministically.
+TEST_CASE("an agent's destruction waits for a fetch started by its worker during teardown",
+          "[MoonrakerPrinterAgent][Regression]")
+{
+    g_deferred_fetch_running.store(0);
+    g_deferred_destroy_returned.store(false);
+
+    auto agent        = std::make_shared<DeferredFetchAgent>(std::string{});
+    auto entered      = agent->entered;
+    auto allow_fetch  = agent->allow_fetch;
+    auto allow_finish = agent->allow_finish;
+    auto running      = agent->running;
+
+    // Safety net for the pre-destroyer failure paths: release both gates before the
+    // agent is destroyed (declared after it, so destroyed before it).
+    ScopedPromiseRelease release_finish{allow_finish};
+    ScopedPromiseRelease release_fetch{allow_fetch};
+
+    // Park a fetch inside the command worker while the agent is still complete.
+    agent->post([ptr = agent.get()] { ptr->fetch_filament_info("dev", FilamentSyncMode::pull); });
+    REQUIRE(entered->get_future().wait_for(std::chrono::seconds(5)) == std::future_status::ready);
+
+    // Destroy on another thread so this one can drive the parked fetch.
+    std::thread destroyer([owned = std::move(agent)]() mutable {
+        owned.reset();
+        g_deferred_destroy_returned.store(true);
+    });
+    // Releases both gates before joining, so a failing REQUIRE cannot deadlock the join.
+    ScopedJoiner join_destroyer{destroyer, allow_fetch, allow_finish};
+
+    // Let the worker reserve the in-flight slot and spawn its fetch, then wait until it
+    // is genuinely parked (no polling).
+    allow_fetch->set_value();
+    REQUIRE(running->get_future().wait_for(std::chrono::seconds(5)) == std::future_status::ready);
+    REQUIRE(g_deferred_fetch_running.load() == 1);
+
+    // A correct teardown cannot return while the fetch is parked; give a buggy one time.
+    for (int i = 0; i < 200 && !g_deferred_destroy_returned.load(); ++i)
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+
+    if (g_deferred_destroy_returned.load()) {
+        // Bug: teardown returned with a fetch still running. Don't release allow_finish.
+        CHECK(g_deferred_fetch_running.load() == 0);
+        return;
+    }
+
+    // Fixed order: destruction is still blocked on the in-flight fetch.
+    allow_finish->set_value();
+    destroyer.join();
+    CHECK(g_deferred_destroy_returned.load());
+    CHECK(g_deferred_fetch_running.load() == 0);
+}
+
 // ===========================================================================
 // UNIT - printer-agent registry duplicate handling.
 // Confirms a duplicate agent id is rejected so a plugin cannot shadow a built-in
 // or previously registered agent.
 // ===========================================================================
-TEST_CASE("unit: printer-agent registry register / lookup / duplicate-reject", "[registry][unit]")
+TEST_CASE("printer-agent registry register / lookup / duplicate-reject", "[PrinterAgent]")
 {
     // why: the registry is process-global state shared by the test binary, and
     // Catch2 may run cases in any order. Use an id that cannot collide with
@@ -69,7 +459,7 @@ TEST_CASE("unit: printer-agent registry register / lookup / duplicate-reject", "
 // fails to load the codecs needed for the filesystem encoding. The shared helper
 // points PyConfig.home at the python/ runtime staged next to the test executable.
 
-TEST_CASE("integration: orca.printer_agent binding surface", "[integration][Python]")
+TEST_CASE("orca.printer_agent binding surface", "[integration][Python]")
 {
     py::module_ orca = import_orca_module();
 
@@ -120,7 +510,7 @@ TEST_CASE("integration: orca.printer_agent binding surface", "[integration][Pyth
 // them in the lightweight embedded-interpreter test catches binding breakage
 // before the plugin-loader test needs to run.
 // ===========================================================================
-TEST_CASE("integration: orca plugin-registration API surface + discovery-context guards", "[integration][Python]")
+TEST_CASE("orca plugin-registration API surface + discovery-context guards", "[integration][Python]")
 {
     py::module_ orca = import_orca_module();
 

tests/slic3rutils/test_qidi_printer_agent.cpp

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

tests/slic3rutils/test_shortcuts.cpp

@@ -126,6 +126,55 @@ TEST_CASE("Only modified or non-printable chords qualify as menu accelerators",
     CHECK(registry.accelerator(Shortcut::KeyboardShortcuts).empty());
 }
 
+TEST_CASE("Typing, caret, deletion and clipboard chords edit text", "[Shortcuts]")
+{
+    CHECK(KeyChord{ 'A' }.edits_text());
+    CHECK(KeyChord{ 'A', wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_SPACE }.edits_text());
+    CHECK(KeyChord{ WXK_BACK }.edits_text());
+    CHECK(KeyChord{ WXK_DELETE }.edits_text());
+    CHECK(KeyChord{ WXK_BACK, wxMOD_CONTROL }.edits_text());
+    CHECK(KeyChord{ WXK_LEFT, wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_RIGHT, wxMOD_CONTROL | wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_HOME }.edits_text());
+    CHECK(KeyChord{ WXK_END, wxMOD_CONTROL }.edits_text());
+    CHECK(KeyChord{ WXK_DELETE, wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_INSERT }.edits_text());
+    CHECK(KeyChord{ WXK_INSERT, wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_INSERT, wxMOD_CONTROL }.edits_text());
+    CHECK(KeyChord{ WXK_PAGEUP, wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_RETURN }.edits_text());
+    CHECK(KeyChord{ WXK_TAB, wxMOD_SHIFT }.edits_text());
+    CHECK(KeyChord{ WXK_ESCAPE }.edits_text());
+    CHECK(KeyChord{ WXK_PAGEDOWN }.edits_text());
+    for (int key : { 'A', 'C', 'V', 'X', 'Y', 'Z' })
+        CHECK(KeyChord{ key, wxMOD_CONTROL }.edits_text());
+    CHECK(KeyChord{ 'Z', wxMOD_CONTROL | wxMOD_SHIFT }.edits_text());
+
+    CHECK_FALSE(KeyChord{ WXK_TAB, wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_RETURN, wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_PAGEDOWN, wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_ESCAPE, wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ 'S', wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ 'S', wxMOD_CONTROL | wxMOD_SHIFT }.edits_text());
+    CHECK_FALSE(KeyChord{ '0', wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_F5 }.edits_text());
+    CHECK_FALSE(KeyChord{}.edits_text());
+#ifdef __APPLE__
+    CHECK(KeyChord{ 'E', wxMOD_ALT }.edits_text());
+    CHECK(KeyChord{ 'K', wxMOD_RAW_CONTROL }.edits_text());
+    CHECK(KeyChord{ WXK_LEFT, wxMOD_ALT }.edits_text());
+    CHECK(KeyChord{ WXK_LEFT, wxMOD_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_LEFT, wxMOD_RAW_CONTROL }.edits_text());
+    CHECK_FALSE(KeyChord{ 'E', wxMOD_CONTROL | wxMOD_ALT }.edits_text());
+#else
+    CHECK(KeyChord{ 'Q', wxMOD_CONTROL | wxMOD_ALT }.edits_text());
+    CHECK_FALSE(KeyChord{ 'E', wxMOD_ALT }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_LEFT, wxMOD_ALT }.edits_text());
+    CHECK_FALSE(KeyChord{ WXK_LEFT, wxMOD_CONTROL | wxMOD_ALT }.edits_text());
+#endif
+}
+
 TEST_CASE("Chords the desktop keeps for itself are recognized", "[Shortcuts]")
 {
 #ifdef _WIN32
@@ -186,6 +235,21 @@ TEST_CASE("Default bindings never collide inside a context", "[Shortcuts]")
     }
 }
 
+TEST_CASE("No default Global binding except the Speed Dial's Space edits text", "[Shortcuts]")
+{
+    ShortcutRegistry registry;
+    size_t           checked = 0;
+    for (size_t i = 0; i < size_t(Shortcut::Count); ++i) {
+        const ShortcutInfo& info = shortcut_info(Shortcut(i));
+        if ((info.contexts & context_bit(ShortcutContext::Global)) == 0 || info.id == Shortcut::SpeedDial)
+            continue;
+        CAPTURE(info.key);
+        CHECK_FALSE(registry.binding(info.id).edits_text());
+        ++checked;
+    }
+    CHECK(checked > 0);
+}
+
 TEST_CASE("Shift and Ctrl variants of stepping shortcuts are left unbound", "[Shortcuts]")
 {
     ShortcutRegistry registry;

version.inc

@@ -7,7 +7,7 @@ set(SLIC3R_APP_KEY "OrcaSlicer")
 if(NOT DEFINED BBL_INTERNAL_TESTING)
 set(BBL_INTERNAL_TESTING "0")
 endif()
-set(SoftFever_VERSION "2.5.0-alpha")
+set(SoftFever_VERSION "2.5.0-dev")
 string(REGEX MATCH "^([0-9]+)\\.([0-9]+)\\.([0-9]+)"
        SoftFever_VERSION_MATCH ${SoftFever_VERSION})
 set(ORCA_VERSION_MAJOR ${CMAKE_MATCH_1})