fix: test fixture

fix: clang-tidy
fix: nozzle & preset sync
2026-10-17 04:41:21 +00:00 · 2026-10-16 22:23:42 +08:00 · 2026-10-16 21:28:37 +08:00 · 2026-10-16 20:51:22 +08:00 · 2026-10-16 20:48:57 +08:00 · 2026-10-15 16:06:50 +08:00
167 changed files with 10946 additions and 45854 deletions
@@ -569,18 +569,12 @@ on the **first** call. So:
 #endif
 ```

-**Before GTK starts**, only the environment exists. `CLI::run` (`src/OrcaSlicer.cpp`) sets the NVIDIA
-DMABUF workaround and then branches on `GDK_BACKEND` (an `x11` prefix means the X11 opt-in). On both
-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`
-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
-Wayland app inherits both). It calls `XInitThreads()`
+**Before GTK starts**, only the environment exists. `CLI::run` (`src/OrcaSlicer.cpp`) branches on
+`GDK_BACKEND` (an `x11` prefix means the X11 opt-in). On the default path it forces `GDK_BACKEND=x11`
+when wx lacks EGL and `WAYLAND_DISPLAY` is set. It sets `WEBKIT_DISABLE_COMPOSITING_MODE=1`
+(non-replacing) only when both `DISPLAY` and `WAYLAND_DISPLAY` are set, and calls `XInitThreads()`
 only when `DISPLAY` is set. With neither variable set, the GUI refuses to start ("Neither DISPLAY nor
-WAYLAND_DISPLAY set"). The details and the WebKit rules (c12912e0df) are in
+WAYLAND_DISPLAY set"). The details and the WebKit rule (c12912e0df) are in
 `references/webview-gl-aui-media.md` §WebKitGTK on Linux sessions.

 **wx's own detectors**, for reference:
@@ -61,8 +61,7 @@ available; GTK2/WebKit1 is an opt-out configuration the GUI does not support.
 11. A web host that re-themes in place handles `EVT_WEBVIEW_RECREATED` without `Skip()`; one that
    needs a reload lets it through. §[Orca wrapper](#orca-webview-wrapper-widgetswebview)
 12. Keep `WebViewWebKit`'s destructor removing the `"wx"` handler. §[Orca wrapper](#orca-webview-wrapper-widgetswebview)
-13. Do not widen `WEBKIT_DISABLE_COMPOSITING_MODE` beyond the no-EGL default path where Orca forces
-    `GDK_BACKEND=x11`, for WebKitGTK older than 2.42, and never
+13. Do not widen `WEBKIT_DISABLE_COMPOSITING_MODE` beyond Orca's default-path XWayland case, and never
    make a page's progress depend only on a C++→JS callback. §[WebKitGTK on Linux](#webkitgtk-on-linux-sessions)
 14. GL attribute lists: legacy `int[]` lists end with `0` and spell out `WX_GL_RGBA` and
    `WX_GL_DOUBLEBUFFER`; `wxGLAttributes`/`wxGLContextAttrs` end with `EndList()`; MSAA is requested
@@ -568,69 +567,33 @@ 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`:
- **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.
+branches on `GDK_BACKEND`:
 - **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
-  (`WebView::NeedsCompositingWorkaround()`). That forced X11 backend in a Wayland session is the only
-  default-path case that really runs through XWayland; `DISPLAY` and `WAYLAND_DISPLAY` alone do not
-  identify it, because a native Wayland app inherits both. `XInitThreads()` runs only when `DISPLAY` is
-  set.
+  `WAYLAND_DISPLAY` is set, it forces `GDK_BACKEND=x11`; it sets `WEBKIT_DISABLE_COMPOSITING_MODE=1`
+  non-replacing **only** when both `DISPLAY` and `WAYLAND_DISPLAY` are non-empty (a Wayland session with
+  XWayland available — the session, not the backend GTK will pick); `XInitThreads()` runs only when
+  `DISPLAY` is set.
 - **`GDK_BACKEND=x11…` opt-in path**: sets `DRI_PRIME=1` (and the NVIDIA PRIME variables when
  `/proc/driver/nvidia/version` exists), calls `XInitThreads()`, and deliberately does **not** disable
-  compositing, which keeps hardware acceleration for Device / Setup Wizard / login pages.
+  compositing (the comment: the WebKit2GTK XWayland bug appears fixed in WebKit2GTK ≥ 2.42, and leaving
+  compositing on keeps hardware acceleration for Device / Setup Wizard / login pages).

 Runtime backend detection elsewhere uses Orca's `is_running_on_wayland()` / `is_running_on_x11()`
 (see `references/platforms.md`), not these environment variables.

 **Pitfall.**
- **Rule:** On NVIDIA reach for `WEBKIT_DMABUF_RENDERER_FORCE_SHM` before
-  `WEBKIT_DISABLE_COMPOSITING_MODE`. **Why:** the proprietary driver cannot back WebKit's 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
-  X11/Wayland fallback renderers were removed) and has a reported crash path. On Debian/Ubuntu and
-  openSUSE the `isNVIDIA()` patch returns before the FORCE_SHM check, so `WEBKIT_FORCE_DMABUF_RENDERER=1`
-  must clear it first; that variable exists only in those patches. WebKit reads all of these once per
-  process, before the first WebView.
-  The test is `/proc/driver/nvidia/version`, so a hybrid laptop that renders on its iGPU also takes the
-  shared-memory path, which is a per-frame GPU readback rather than zero-copy; exporting
-  `WEBKIT_DMABUF_RENDERER_FORCE_SHM=0` in the environment restores the hardware path.
-  ```cpp
-  // Wrong: kills compositing and threaded scrolling (and can crash on modern WebKit)
-  ::setenv("WEBKIT_DISABLE_DMABUF_RENDERER", "1", false);
-  // Right: keep compositing, skip only the hardware DMABUF path
-  if (::access("/proc/driver/nvidia/version", F_OK) == 0 && WebView::SupportsForceSharedMemory()) {
-      ::setenv("WEBKIT_DMABUF_RENDERER_FORCE_SHM", "1", /*replace*/ false);
-      ::setenv("WEBKIT_FORCE_DMABUF_RENDERER", "1", /*replace*/ false);
-  }
-  ```
-  Cite: WebKit 2.52.6 `Source/WebKit/UIProcess/gtk/AcceleratedBackingStore.cpp`
-  (`rendererBufferTransportMode()`), Debian `disable-nvidia-dmabuf.patch`, WebKit bug 262607.
- **Rule:** Set `WEBKIT_DISABLE_COMPOSITING_MODE` only on the default path, in the branch where wx
-  lacks EGL and Orca forces `GDK_BACKEND=x11`, non-replacing (`setenv(..., false)`, so a value the user
-  already exported wins), before GTK
-  initialises; never unconditionally, and only for the WebKitGTK releases that need it (older than
-  2.42, `WebView::NeedsCompositingWorkaround()`). Keep JS-side fallbacks so a page never
+- **Rule:** Set `WEBKIT_DISABLE_COMPOSITING_MODE` only on the default path in Wayland sessions,
+  non-replacing (`setenv(..., false)`, so a value the user already exported wins), before GTK
+  initialises; never unconditionally. Keep JS-side fallbacks so a page never
  waits forever for a C++→JS call.
-  **Why:** WebKit2GTK accelerated compositing could fail silently under XWayland before 2.42, leaving
-  web views blank (Setup Wizard stuck on "Loading..."); the variable also turns off threaded scrolling,
-  so applying it on a newer WebKit needlessly drops both GPU compositing and async scrolling (the
-  Device tab loses its smoothness); without the JS timeout the user is stuck when the signal is lost.
+  **Why:** WebKit2GTK accelerated compositing could fail silently under XWayland, leaving web views
+  blank (Setup Wizard stuck on "Loading..."); disabling it everywhere needlessly drops hardware
+  acceleration; without the JS timeout the user is stuck when the signal is lost.
  ```cpp
  // Wrong: unconditional, kills HW acceleration everywhere
  ::setenv("WEBKIT_DISABLE_COMPOSITING_MODE", "1", false);
-  // Right (default path only): non-replacing, before GTK init, WebKitGTK < 2.42,
-  // and only in the branch that forces GDK_BACKEND=x11 (wx without EGL), the
-  // case that runs through XWayland
-  if (WebView::NeedsCompositingWorkaround() && wayland && *wayland)
+  // Right (default path only): non-replacing, before GTK init, Wayland session with XWayland
+  if (display && *display && wayland && *wayland)
      ::setenv("WEBKIT_DISABLE_COMPOSITING_MODE", "1", /*replace*/ false);
  ```
  Cite: c12912e0df (`src/OrcaSlicer.cpp`; `resources/web/guide/0/load.js` `OnInit`
@@ -288,19 +288,6 @@ 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")
@@ -22,7 +22,7 @@ function usage() {
    echo "   -g: run the requested build steps inside a Docker/Podman Ubuntu 24.04 container similar to the GitHub Actions Linux runner"
    echo "   -h: prints this help text"
    echo "   -i: build the Orca Slicer AppImage (optional)"
-    echo "   -p: disable precompiled headers (on by default): more ccache hits after header changes, slower misses"
+    echo "   -p: boost ccache hit rate by disabling precompiled headers (default: ON)"
    echo "   -r: skip RAM and disk checks (low RAM compiling)"
    echo "   -s: build the Orca Slicer (optional)"
    echo "   -t: build tests (optional), requires -s flag"
@@ -549,20 +549,6 @@ fi
 if [ -n "${CMAKE_CCACHE}" ] ; then
    echo "${CMAKE_CCACHE} found, enabling compiler caching..."
    export 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."
 fi
@@ -111,54 +111,6 @@ 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"
@@ -210,7 +162,6 @@ 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
@@ -313,7 +264,6 @@ 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"
@@ -1,7 +1,22 @@
+if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+    if (JPEG_VERSION STREQUAL "6")
+        message("Using Jpeg Lib 62")
+        set(jpeg_flag "")
+    elseif (JPEG_VERSION STREQUAL "7")
+        message("Using Jpeg Lib 70")
+        set(jpeg_flag "-DWITH_JPEG7=ON")
+    else ()
+        message("Using Jpeg Lib 80")
+        set(jpeg_flag "-DWITH_JPEG8=ON")
+    endif ()
+endif()
+
 orcaslicer_add_cmake_project(JPEG
-    URL https://github.com/libjpeg-turbo/libjpeg-turbo/archive/refs/tags/3.2.0.zip
-    URL_HASH SHA256=1b4c2cb6cba1ca5e53b9e85eeeab02154cab4b70894c96e97a9c747a26d19d63
+    URL https://github.com/libjpeg-turbo/libjpeg-turbo/archive/refs/tags/3.0.1.zip
+    URL_HASH SHA256=d6d99e693366bc03897677650e8b2dfa76b5d6c54e2c9e70c03f0af821b0a52f
+    DEPENDS ${ZLIB_PKG}
    CMAKE_ARGS
        -DENABLE_SHARED=OFF
        -DENABLE_STATIC=ON
+        ${jpeg_flag}
 )
@@ -0,0 +1,233 @@
+# Multi-extruder and multi-AMS device control
+
+`DeviceManager`/`MachineObject` model the toolheads, AMS units, and filament slots of a connected
+printer and drive the device-control UI from that model. The model represents the counts as
+device-reported runtime values rather than compile-time caps, so a printer with an arbitrary number
+of toolheads, several AMS units, and a non-uniform number of slots per unit is handled by the same
+code paths. The printer agent is responsible for translating its printer's state into the shared
+JSON dialect this model consumes; the agent boundary is described in
+[printer-agent.md](printer-agent.md), and this document describes the dialect and the model.
+
+## Model layout
+
+`MachineObject` owns the device subsystems that this document covers:
+
+- `DevExtderSystem` — the toolheads (extruders) and their per-toolhead filament/temperature state.
+- `DevFilaSystem` — the AMS units (`DevAms`) and their trays (`DevAmsTray`).
+- `DevNozzleSystem` — the nozzles and, on rack printers, `DevNozzleRack`.
+- `DevFilaSwitch` — a filament switch that can feed several AMS units to more than one extruder.
+
+Each subsystem exposes its own count — `DevExtderSystem::GetTotalExtderCount()`,
+`DevFilaSystem::GetAmsCount()`, `DevAms::GetSlotCount()` — and the rest of the application derives
+its layout from those values rather than from fixed assumptions.
+
+## Wire dialect
+
+The dialect is the Bambu-shaped JSON that `DeviceManager` and `MachineObject` already consume. An
+agent whose printer speaks something else is expected to translate into it; the agent is not free
+to invent a new shape. Two representations coexist for extruders, and one for AMS/slots.
+
+### Extruders
+
+The generic representation is `print.device.extruder`, parsed by
+`ExtderSystemParser::ParseV2_0` (`DevExtruderSystem.cpp`). It has a packed `state` integer and an
+`info` array with one object per toolhead:
+
+```text
+device.extruder.state           packed integer
+  bits  0..3   total extruder count
+  bits  4..7   current extruder id
+  bits  8..11  target extruder id
+  bits 12..14  switch state
+  bits 15..18  currently loading extruder id
+  bit   19     busy for loading
+
+device.extruder.info[]          one entry per toolhead
+  id          extruder id
+  filam_bak   array of backup-group bits
+  info        bit 1 has filament, bit 2 buffer has filament, bit 3 nozzle present
+  temp        bits 0..15 current temperature, bits 16..31 target temperature
+  spre        slot_id bits 0..7, ams_id bits 8..15 (previous)
+  snow        same packing (current)
+  star        same packing (target)
+  stat        bit 0..15 AMS status, bits 16..31 RFID status
+  hnow        current nozzle id
+```
+
+The legacy single/dual representation is the pair of scalar fields `nozzle_temper` /
+`nozzle_target_temper`, plus the `print.ams.tray_tar` / `tray_now` tray pointer, parsed by
+`ExtderSystemParser::ParseV1_0`. That parser is a fallback and only fills the main extruder when the
+reported toolhead count is one.
+
+Physical extruder ids are fixed (`MAIN_EXTRUDER_ID = 0`, `DEPUTY_EXTRUDER_ID = 1`). Bambu printers
+present the two toolheads as a left/right pair and invert the physical-to-logical mapping; generic
+printers use the toolhead id itself as the logical id. `DevNozzle::GetLogicExtruderId()` /
+`GetExtruderId()` centralise that distinction.
+
+### AMS units and slots
+
+AMS units arrive as `print.ams.ams[]` and are parsed by `DevFilaSystemParser::ParseV1_0`. Each unit
+carries an `id` and an `info` bitfield:
+
+```text
+info bits  0..3    type: 0 dummy, 1 AMS, 2 AMS-Lite, 3 N3F, 4 N3S, 5 AMS-Lite-mixed (N9)
+info bits  8..11   bound extruder id (0xE marks a switch-bound unit)
+info bits 24..27   switch inlet when the unit is switch-bound
+```
+
+`DevAmsType` (`DevDefs.h`) enumerates the resulting unit kinds: `EXT_SPOOL`, `AMS`, `AMS_LITE`,
+`N3F`, `N3S`, and the `AMS_LITE_MIXED` N9 variant. `AMS_LITE_MIXED` reports itself as `AMS_LITE` to
+generic callers; code that needs the distinction uses `IsAmsLiteMixed()`.
+
+A unit whose bound-extruder nibble is `0xE` is switch-bound: it is kept only when a `DevFilaSwitch`
+is installed, in which case its extruder id is pinned to the main extruder and its binding set
+becomes `{0, 1}`; otherwise the unit is dropped from the AMS list.
+
+Each unit owns a map of `DevAmsTray` keyed by the tray id from the payload. The slot count is a
+property of the unit kind and the reported trays:
+
+- `AMS`, `AMS_LITE`, and `N3F` report four slots on Bambu printers, matching the firmware contract;
+- `N3S` reports one slot;
+- `EXT_SPOOL` and any non-Bambu unit report the number of trays actually present.
+
+The tray ids are the payload's slot indices; they are expected to be unique, 0-based, and contiguous
+within a unit, because the generic tray-index mapping below is cumulative.
+
+### External spool slots
+
+External/manual spools are virtual trays in `MachineObject::vt_slot`, separate from the trays owned
+by `DevFilaSystem`. Their stable id is `vt_id = VIRTUAL_TRAY_MAIN_ID - extruder_id`: 255 for
+extruder 0, 254 for extruder 1, then 253, 252, and so on. The index in `vt_slot` is therefore
+`VIRTUAL_TRAY_MAIN_ID - vt_id`, not the order in which a printer happens to report trays.
+
+For non-Bambu printers, slot topology comes from the live `DevExtderSystem` extruder count, not from
+external-spool telemetry. `MachineObject::ensure_external_virtual_tray_slots()` grows `vt_slot` to
+one entry per extruder and enables virtual-tray support even when the agent reports no `vir_slot`,
+`vt_tray`, or external-spool data. It only adds missing entries, so reported tray metadata is kept.
+The shared ensure runs after push-status parsing has updated the extruder count and after the generic
+AMS/agent-filament parsers. Thus agents may report external-spool metadata, but do not have to invent
+empty slots just to make each toolhead's external-spool row visible.
+
+When a payload does report virtual trays, `vir_slot` entries are placed by their id and missing
+indices are filled with placeholders. Generic agent `external` entries are likewise placed by
+extruder id, so sparse or out-of-order reports do not shift a spool onto another toolhead. An empty
+placeholder represents the slot's existence, not a claim that the printer reported a loaded spool.
+Bambu keeps its fixed 255/254 virtual-tray pair and does not use generic slot synthesis.
+
+## Mapping
+
+Several subsystems relate AMS units, trays, and extruders, and more than one place derives a tray
+index. Bambu mapping computes `ams_id * 4 + slot_id` for its fixed-width units; generic mapping in
+`DevFilaSystem` and the sidebar matcher uses the count of lanes in preceding units plus the slot id.
+The two agree for Bambu units and differ for a non-Bambu unit whose slot count is not four.
+
+### AMS id to extruder id
+
+`DevFilaSystem::GetExtruderIdByAmsId()` resolves an AMS id to the extruder it feeds:
+
+- an AMS unit returns its bound extruder (`DevAms::GetExtruderId()`);
+- a virtual tray returns `VIRTUAL_TRAY_MAIN_ID - vt_id`;
+- Bambu's virtual AMS ids map to the main/deputy extruder.
+
+A unit may be bound to more than one extruder when a `DevFilaSwitch` feeds it; the binding set
+(`DevAms::m_binded_extruder_set`) and switch inlet are read by switch-aware code while the
+single-extruder id stays pinned for legacy callers.
+
+### Tray index
+
+`DevFilaSystem::GetTrayIndexMap()` maps a global tray index to an `(ams_id, slot_id)` pair and is
+used for backup-slot translation, calibration addressing, and the mapping popups.
+
+- Bambu AMS: `ams_id * 4 + slot_id`; N3S: the AMS id; AMS-Lite-mixed (N9): `24 + slot_id`.
+- Generic (non-Bambu): a running lane index — the count of trays in preceding units plus the slot
+  id. This depends on each unit's tray ids being 0-based and contiguous.
+
+The sidebar sync matcher uses the same identities. Bambu retains its fixed left/right AMS and
+external-spool choices. For a generic printer, a full sync considers AMS units according to their
+bound extruder ids and considers every external slot by `255 - vt_id`; a split left/right mapping
+still restricts itself to the corresponding legacy extruders 0 and 1. Generic AMS lanes use the
+cumulative tray index above, while their `ams_id`/`slot_id` pair remains the address used to update
+the matching sidebar entry. The runtime filament-list configs also carry a transient device-extruder
+association so generic entries are grouped under the correct toolhead after sync; that association
+is removed before the configs enter the slicing pipeline. Bambu keeps the existing key-based
+left/right grouping.
+
+### Virtual-slot recognition
+
+`devPrinterUtil::IsVirtualSlot()` decides whether an id denotes a virtual tray. On Bambu printers it
+is the fixed pair `{255, 254}`. On generic printers it is the descending range
+`[255 - count + 1, 255]`, where `count` is the selected printer preset's extruder count. Slot
+topology is grown from the live device extruder count, while this recognition range still uses the
+preset count; the preset is expected to match the connected device. A mismatch can therefore make
+the recognized virtual-id range disagree with `vt_slot`, and is reported by the existing count
+warning rather than silently accepted.
+
+## Device-control UI
+
+The device-control widgets follow the same device-reported counts.
+
+- `AMSModel` (`AMSItem.hpp`) mirrors `DevAmsType` numerically: `EXT_AMS`, `GENERIC_AMS`, `AMS_LITE`,
+  `N3F_AMS`, `N3S_AMS`. A plain `AMS` maps to `GENERIC_AMS`.
+- On non-Bambu printers `use_generic_ams_layout()` routes `GENERIC_AMS` units through a variable-lane
+  rendering that draws one lane per reported tray; Bambu keeps its fixed four-slot rendering.
+- `AMSControl` picks its layout by toolhead count, not vendor: `CreateAmsSingleNozzle` for one
+  toolhead, `CreateAmsDoubleNozzle` for two, and `CreateAmsMultiNozzle` (one preview and one AMS
+  simplebook per toolhead) for three or more. A two-toolhead generic printer therefore keeps the
+  legacy left/right presentation; that is deliberate.
+- The status panel builds external-spool entries from `MachineObject::vt_slot`; generic slot
+  synthesis keeps one empty entry available for each live toolhead even when the printer does not
+  report external-spool state.
+- The status panel's `ExtruderImage` renders one per-toolhead state per nozzle and is resized to
+  `GetTotalExtderCount()`. Non-Bambu printers choose the active toolhead through
+  `m_generic_nozzle_selector` (shown when more than one toolhead exists); Bambu keeps its left/right
+  `m_nozzle_btn_panel`. Nozzle temperature controls are created on demand per toolhead.
+
+## Constraints
+
+- **Single dialect.** The agent translates its protocol into this JSON; the model does not learn
+  vendor protocols. Extending the model with a new unit kind or field means extending the dialect.
+- **Runtime counts.** The agent reports toolhead count and AMS unit/tray data. The shared model derives
+  generic external-spool slot count from the parsed live toolhead count; nothing caps the number of
+  toolheads or generic slots except the id range and the Bambu contract described above.
+- **Extruder dialect invariants.** `device.extruder.state`'s count field must equal the length of
+  `info[]`, and `info[]` must be ordered by extruder id with `id` equal to the array index: the
+  parser places toolheads by array position while `GetExtderById()` indexes by id.
+- **One filament road per toolhead.** Each toolhead renders a single AMS filament road rather than an
+  independent per-toolhead road state. A generic scaffold that allowed the latter was removed as
+  unused; the one-extruder-per-toolhead road is the intended model.
+- **Preset/device agreement.** The generic layout and virtual-slot range derive their count from the
+  selected printer preset. A printer preset must therefore declare the same number of
+  `nozzle_diameter` entries as the device has toolheads. A mismatch is surfaced only as a log warning
+  (`StatusPanel::check_extruder_count_mismatch()`), deliberately log-only, because the sidebar and
+  extruder logic would otherwise silently disagree.
+- **Bambu compatibility.** Bambu-specific presentation (left/right pair, fixed 4-slot units, fixed
+  virtual ids, physical/logical inversion) is preserved behind the vendor check. Generic paths do
+  not alter it.
+- **Tray-index invariant.** The generic tray-index map is cumulative, so payload tray ids must be
+  unique, 0-based, and contiguous per unit. A malformed id is a producer error.
+- **Protocol markers.** The dialect has no neutral equivalent for some Bambu state, so agents that
+  lack it send empty `print.cfg`, `print.fun`, `print.aux`, and `print.stat`. Their presence selects
+  the new-protocol parse path; they are compatibility markers, not feature switches.
+
+## Main implementation locations
+
+- [`DevExtruderSystem`](../../src/slic3r/GUI/DeviceCore/DevExtruderSystem.h) — toolhead model and the
+  `device.extruder` parser
+- [`DevFilaSystem`](../../src/slic3r/GUI/DeviceCore/DevFilaSystem.h) — AMS/tray model, the AMS parser,
+  and the mapping helpers
+- [`DevMapping.cpp`](../../src/slic3r/GUI/DeviceCore/DevMapping.cpp) — filament-to-device tray matching
+  for Bambu and generic external/AMS slots
+- [`PresetBundle.cpp`](../../src/libslic3r/PresetBundle.cpp) — per-extruder grouping of the transient
+  device filament list
+- [`DevDefs.h`](../../src/slic3r/GUI/DeviceCore/DevDefs.h) — `DevAmsType`, extruder ids, and virtual
+  tray ids
+- [`DeviceManager.cpp`](../../src/slic3r/GUI/DeviceManager.cpp) — message dispatch, `vir_slot`
+  parsing, external-slot topology, and device state assembly
+- [`AMSControl.cpp`](../../src/slic3r/GUI/Widgets/AMSControl.cpp) — per-toolhead AMS panes
+  (`CreateAmsMultiNozzle`) and the generic layout
+- [`AMSItem.hpp`](../../src/slic3r/GUI/Widgets/AMSItem.hpp) — `AMSModel` and the variable-lane AMS
+  rendering
+- [`StatusPanel.cpp`](../../src/slic3r/GUI/StatusPanel.cpp) — `ExtruderImage`, the toolhead selector,
+  and per-toolhead temperature controls
+- [`MoonrakerPrinterAgent.cpp`](../../src/slic3r/Utils/MoonrakerPrinterAgent.cpp) — producer example
+  (AMS payload and the `device.extruder` encoding)
@@ -1 +1 @@
-<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 15 15"><rect x="1.5" y="3.5" width="12" height="8" rx="1" ry="1" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/><path d="M3,5h1v1h-1Z M5,5h1v1h-1Z M7,5h1v1h-1Z M9,5h1v1h-1Z M11,5h1v1h-1Z M4,7h1v1h-1Z M6,7h1v1h-1Z M8,7h1v1h-1Z M10,7h1v1h-1Z M5,9h5v1h-5Z" style="fill:#fefefe;"/></svg>
+<?xml version="1.0" encoding="UTF-8"?><svg id="a" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 15 15"><rect x="7" y="12" width="1" height="1" style="fill:#fefefe;"/><path d="M4.5,5.5c0-1.71,1.43-3.09,3.16-3,1.62.08,2.84,1.54,2.84,3.17h0c0,.61-.25,1.2-.69,1.62l-2.31,2.24v.97" style="fill:none; stroke:#fefefe; stroke-linecap:round; stroke-linejoin:round;"/></svg>
@@ -592,10 +592,6 @@
 			"name": "SUNLU PETG @base",
 			"sub_path": "filament/SUNLU/SUNLU PETG @base.json"
 		},
-		{
-			"name": "School House Spools PETG @base",
-			"sub_path": "filament/SchoolHouseSpools/School House Spools PETG @base.json"
-		},
 		{
 			"name": "eSUN PETG @base",
 			"sub_path": "filament/eSUN/eSUN PETG @base.json"
@@ -1100,10 +1096,6 @@
 			"name": "SUNLU Wood PLA @base",
 			"sub_path": "filament/SUNLU/SUNLU Wood PLA @base.json"
 		},
-		{
-			"name": "School House Spools PLA @base",
-			"sub_path": "filament/SchoolHouseSpools/School House Spools PLA @base.json"
-		},
 		{
 			"name": "Valment PLA @base",
 			"sub_path": "filament/Valment/Valment PLA @base.json"
@@ -2268,10 +2260,6 @@
 			"name": "SUNLU PETG @System",
 			"sub_path": "filament/SUNLU/SUNLU PETG @System.json"
 		},
-		{
-			"name": "School House Spools PETG @System",
-			"sub_path": "filament/SchoolHouseSpools/School House Spools PETG @System.json"
-		},
 		{
 			"name": "eSUN PETG @System",
 			"sub_path": "filament/eSUN/eSUN PETG @System.json"
@@ -3824,10 +3812,6 @@
 			"name": "SUNLU Wood PLA @System",
 			"sub_path": "filament/SUNLU/SUNLU Wood PLA @System.json"
 		},
-		{
-			"name": "School House Spools PLA @System",
-			"sub_path": "filament/SchoolHouseSpools/School House Spools PLA @System.json"
-		},
 		{
 			"name": "Valment PLA @System",
 			"sub_path": "filament/Valment/Valment PLA @System.json"
@@ -1,18 +0,0 @@
-{
-	"type": "filament",
-	"name": "School House Spools PETG @System",
-	"inherits": "School House Spools PETG @base",
-	"from": "system",
-	"setting_id": "RSu2orfhR8ktT36h",
-	"instantiation": "true",
-	"filament_max_volumetric_speed": [
-		"13"
-	],
-	"filament_long_retractions_when_cut": [
-		"1"
-	],
-	"filament_retraction_distances_when_cut": [
-		"18"
-	],
-	"compatible_printers": []
-}
@@ -1,80 +0,0 @@
-{
-	"type": "filament",
-	"name": "School House Spools PETG @base",
-	"inherits": "fdm_filament_pet",
-	"from": "system",
-	"filament_id": "OFnaCGQ9",
-	"instantiation": "false",
-	"cool_plate_temp": [
-		"0"
-	],
-	"cool_plate_temp_initial_layer": [
-		"0"
-	],
-	"eng_plate_temp": [
-		"70"
-	],
-	"eng_plate_temp_initial_layer": [
-		"70"
-	],
-	"fan_cooling_layer_time": [
-		"30"
-	],
-	"fan_max_speed": [
-		"40"
-	],
-	"fan_min_speed": [
-		"10"
-	],
-	"filament_cost": [
-		"16.00"
-	],
-	"filament_density": [
-		"1.25"
-	],
-	"filament_flow_ratio": [
-		"0.95"
-	],
-	"filament_max_volumetric_speed": [
-		"8"
-	],
-	"filament_multitool_ramming_flow": [
-		"8"
-	],
-	"filament_vendor": [
-		"School House Spools"
-	],
-	"hot_plate_temp": [
-		"70"
-	],
-	"hot_plate_temp_initial_layer": [
-		"70"
-	],
-	"nozzle_temperature": [
-		"252"
-	],
-	"nozzle_temperature_initial_layer": [
-		"252"
-	],
-	"nozzle_temperature_range_high": [
-		"270"
-	],
-	"nozzle_temperature_range_low": [
-		"230"
-	],
-	"overhang_fan_speed": [
-		"90"
-	],
-	"overhang_fan_threshold": [
-		"10%"
-	],
-	"slow_down_layer_time": [
-		"12"
-	],
-	"textured_plate_temp": [
-		"70"
-	],
-	"textured_plate_temp_initial_layer": [
-		"70"
-	]
-}
@@ -1,18 +0,0 @@
-{
-	"type": "filament",
-	"name": "School House Spools PLA @System",
-	"inherits": "School House Spools PLA @base",
-	"from": "system",
-	"setting_id": "3rHJk6SVAvFzyHI0",
-	"instantiation": "true",
-	"filament_max_volumetric_speed": [
-		"21"
-	],
-	"filament_long_retractions_when_cut": [
-		"1"
-	],
-	"filament_retraction_distances_when_cut": [
-		"18"
-	],
-	"compatible_printers": []
-}
@@ -1,35 +0,0 @@
-{
-	"type": "filament",
-	"name": "School House Spools PLA @base",
-	"inherits": "fdm_filament_pla",
-	"from": "system",
-	"filament_id": "OFHzwmT9",
-	"instantiation": "false",
-	"filament_cost": [
-		"17.00"
-	],
-	"filament_density": [
-		"1.26"
-	],
-	"filament_flow_ratio": [
-		"0.98"
-	],
-	"filament_max_volumetric_speed": [
-		"12"
-	],
-	"filament_vendor": [
-		"School House Spools"
-	],
-	"filament_scarf_seam_type": [
-		"none"
-	],
-	"filament_scarf_height": [
-		"10%"
-	],
-	"filament_scarf_gap": [
-		"0%"
-	],
-	"filament_scarf_length": [
-		"10"
-	]
-}
@@ -1,6 +1,6 @@
 {
 	"name": "RatRig",
-	"version": "02.04.00.07",
+	"version": "02.04.00.06",
 	"force_update": "0",
 	"description": "RatRig configurations",
 	"machine_model_list": [
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -107,7 +107,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -107,7 +107,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -107,7 +107,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -106,7 +106,7 @@
 	"z_hop": [
 		"0.2"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single] TOTAL_LAYER_COUNT={total_layer_count} X0={first_layer_print_min[0]} Y0={first_layer_print_min[1]} X1={first_layer_print_max[0]} Y1={first_layer_print_max[1]}",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n_ON_LAYER_CHANGE LAYER={layer_num + 1}",
 	"change_filament_gcode": "M600",
@@ -131,7 +131,7 @@
 	"bed_exclude_area": [
 		"0x0"
 	],
-	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] EXTRUDER_OTHER_LAYER_TEMP=[nozzle_temperature] BED_TEMP=[bed_temperature_initial_layer_single]",
+	"machine_start_gcode": "START_PRINT EXTRUDER_TEMP=[nozzle_temperature_initial_layer] BED_TEMP=[bed_temperature_initial_layer_single]",
 	"machine_end_gcode": "END_PRINT",
 	"layer_change_gcode": ";AFTER_LAYER_CHANGE\n;[layer_z]",
 	"before_layer_change_gcode": ";BEFORE_LAYER_CHANGE\n;[layer_z]\nG92 E0\n",
@@ -18,7 +18,7 @@
  <script src="../js/plugin-config-ui.js"></script>
  <script src="./index.js"></script>
  <script src="./plugin-sort.js"></script>
-  <script src="../../js/fuzzy-search.js"></script>
+  <script src="../js/fuzzy-search.js"></script>
  <script src="./plugin-search.js"></script>
 </head>
 <body onLoad="OnInit()">
@@ -156,16 +156,12 @@ function SetCloudMode( bOn )

 	m_CloudMode=bOn;
 	$("body").toggleClass("cloud-mode", bOn);
-
-	if( bOn )
-	{
-		$(".BtnItem").removeClass("BtnItemSelected");
-		$(".BtnShortcut").addClass("BtnItemSelected");
-	}
 }

 function GotoCloud()
 {
+	$(".BtnItem").removeClass("BtnItemSelected");
+	$(".BtnShortcut").addClass("BtnItemSelected");
 	SetCloudMode(true);
 	SendSimpleCommand("homepage_open_cloud");
 }
@@ -336,10 +336,10 @@ modules:
        sha256: 3d22d46c566b1761a0e15ea397589b3a5f36ac09b7c785382e6470156c04247f
        dest: external-packages/PNG

-      # libjpeg-turbo 3.2.0
+      # libjpeg-turbo 3.0.1
      - type: file
-        url: https://github.com/libjpeg-turbo/libjpeg-turbo/archive/refs/tags/3.2.0.zip
-        sha256: 1b4c2cb6cba1ca5e53b9e85eeeab02154cab4b70894c96e97a9c747a26d19d63
+        url: https://github.com/libjpeg-turbo/libjpeg-turbo/archive/refs/tags/3.0.1.zip
+        sha256: d6d99e693366bc03897677650e8b2dfa76b5d6c54e2c9e70c03f0af821b0a52f
        dest: external-packages/JPEG

      # Freetype 2.12.1
@@ -1,7 +1,7 @@
 #!/usr/bin/env sh

-# WebKit's NVIDIA DMABUF workaround (gnome-build-meta#754) is applied by the
-# binary itself, gated on the runtime WebKitGTK version (src/OrcaSlicer.cpp).
+# Work-around https://gitlab.gnome.org/GNOME/gnome-build-meta/-/issues/754
+grep -q org.freedesktop.Platform.GL.nvidia /.flatpak-info && export WEBKIT_DISABLE_DMABUF_RENDERER=1

 # Work-around https://github.com/bambulab/BambuStudio/issues/3440
 # Use LC_NUMERIC instead of LC_ALL to prevent decimal separator issues
@@ -163,7 +163,6 @@ using json = nlohmann::json;
 #include <X11/Xlib.h>
 #endif
 #include <unistd.h>
-#include "slic3r/GUI/Widgets/WebView.hpp"
 #endif

 #ifdef SLIC3R_GUI
@@ -1157,10 +1156,8 @@ int CLI::run(int argc, char **argv)
    // opt-in path. The ~2020-era WebKit2GTK XWayland compositor bug it
    // worked around appears fixed in WebKit2GTK >= 2.42; leaving it
    // unset preserves WebKit hardware acceleration on Device / Setup
-    // Wizard / login / store. The default path applies it only where it
-    // forces GDK_BACKEND=x11 below (a build without EGL, so the app really
-    // runs through XWayland), and only when the linked WebKitGTK predates
-    // the fix (< 2.42), as a conservative fallback for older WebKit.
+    // Wizard / login / store. The default path still applies it on
+    // XWayland sessions as a conservative fallback for older WebKit.
    // ------------------------------------------------------------------
    {
        const char* gdk_backend = ::getenv("GDK_BACKEND");
@@ -1168,14 +1165,6 @@ int CLI::run(int argc, char **argv)
        // honours the first backend in the comma-separated list).
        const bool x11_opt_in = gdk_backend && boost::starts_with(gdk_backend, "x11");

-        // NVIDIA's proprietary driver cannot back WebKitGTK's DMABUF renderer.
-        // Force the shared-memory transport, which keeps compositing and threaded
-        // scrolling; the second variable clears Debian/Ubuntu/openSUSE's isNVIDIA().
-        if (::access("/proc/driver/nvidia/version", F_OK) == 0 && WebView::SupportsForceSharedMemory()) {
-            ::setenv("WEBKIT_DMABUF_RENDERER_FORCE_SHM", "1", /* replace */ false);
-            ::setenv("WEBKIT_FORCE_DMABUF_RENDERER", "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.";
@@ -1215,18 +1204,23 @@ int CLI::run(int argc, char **argv)
                if (wayland_env && *wayland_env) {
                    BOOST_LOG_TRIVIAL(warning) << "Wayland detected but wxWidgets has no EGL support (wxHAS_EGL is OFF). Forcing X11 backend.";
                    ::setenv("GDK_BACKEND", "x11", true);
-
-                    // GTK will use X11 in a Wayland session here, which is the
-                    // one default-path case that really runs through XWayland.
-                    // WebKit2GTK accelerated compositing could fail silently
-                    // there on releases before 2.42, so force it off. Disabling
-                    // it also turns off threaded scrolling, hence the gate.
-                    if (WebView::NeedsCompositingWorkaround())
-                        ::setenv("WEBKIT_DISABLE_COMPOSITING_MODE", "1", /* replace */ false);
                }
            }
            #endif

+            // WebKit2GTK compositing can fail under XWayland on older
+            // WebKit releases. Disable it only when both DISPLAY and
+            // WAYLAND_DISPLAY are set (i.e. an XWayland session is in
+            // use). On pure X11 or native Wayland, compositing is left
+            // enabled so WebKit retains HW acceleration.
+            {
+                const char* display_env_wk = ::getenv("DISPLAY");
+                const char* wayland_env_wk = ::getenv("WAYLAND_DISPLAY");
+                if (display_env_wk && *display_env_wk && wayland_env_wk && *wayland_env_wk) {
+                    ::setenv("WEBKIT_DISABLE_COMPOSITING_MODE", "1", /* replace */ false);
+                }
+            }
+
            // XInitThreads is needed before GStreamer may use Xlib. On
            // native Wayland without DISPLAY, GStreamer uses waylandsink
            // (no Xlib involved), so the call is skipped.
@@ -429,8 +429,7 @@ if [ "\$XDG_SESSION_TYPE" = "wayland" ] && [ "\$ZINK_DISABLE_OVERRIDE" != "1" ];
                export __EGL_VENDOR_LIBRARY_FILENAMES=/usr/share/glvnd/egl_vendor.d/50_mesa.json
                export MESA_LOADER_DRIVER_OVERRIDE=zink
                export GALLIUM_DRIVER=zink
-                # WebKit's NVIDIA DMABUF workaround is applied by the binary itself,
-                # gated on the runtime WebKitGTK version (src/OrcaSlicer.cpp).
+                export WEBKIT_DISABLE_DMABUF_RENDERER=1
            fi
        fi
    fi
@@ -812,8 +812,7 @@ 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 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.
+     * Odd walls should always go after their enclosing wall polygons.
     *
     * \param outer_to_inner Whether the wall polygons with a lower inset_idx should go before those with a higher one.
 */
@@ -887,7 +886,12 @@ 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 ((nearby->inset_idx < here->inset_idx) == outer_to_inner) {
+            if (here->is_odd || nearby->is_odd) {
+                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);
@@ -432,36 +432,27 @@ static std::vector<Vec2d> get_path_of_change_filament(const Print& print)

    std::string OozePrevention::pre_toolchange(GCode& gcodegen)
    {
+        std::string gcode;
+
        unsigned int extruder_id = gcodegen.writer().filament()->id();
-
-        // Check if this tool will ever be used again in this print.
-        bool is_last_use = false;
-        if (gcodegen.m_print != nullptr && !gcodegen.m_print->tool_ordering().empty()) {
-            coordf_t current_z        = gcodegen.layer() ? gcodegen.layer()->print_z : gcodegen.writer().get_position().z();
-            const auto& tool_ordering = gcodegen.m_print->tool_ordering();
-            const auto& cfg           = gcodegen.config();
-            const int heater          = imex_physical_heater_for(cfg.is_imex.value, cfg.physical_extruder_map, int(extruder_id));
-            is_last_use               = tool_ordering.is_last_extrusion_layer(current_z, extruder_id);
-            for (unsigned int f : tool_ordering.all_extruders())
-                if (is_last_use && imex_physical_heater_for(cfg.is_imex.value, cfg.physical_extruder_map, int(f)) == heater)
-                    is_last_use = tool_ordering.is_last_extrusion_layer(current_z, f);
-        }
-
-        int temp = 0;
-        if (!is_last_use) {
-            const auto& filament_idle_temp = gcodegen.config().idle_temperature;
-            if (filament_idle_temp.get_at(extruder_id) == 0) {
-                if (gcodegen.config().standby_temperature_delta.value == 0)
-                    return std::string();
-                temp = this->_get_temp(gcodegen) + gcodegen.config().standby_temperature_delta.value;
-            } else {
-                temp = filament_idle_temp.get_at(extruder_id);
+        const auto& filament_idle_temp = gcodegen.config().idle_temperature;
+        if (filament_idle_temp.get_at(extruder_id) == 0) {
+            // There is no idle temperature defined in filament settings.
+            // Use the delta value from print config.
+            if (gcodegen.config().standby_temperature_delta.value != 0) {
+                // we assume that heating is always slower than cooling, so no need to block
+                gcode += gcodegen.writer().set_temperature
+                (this->_get_temp(gcodegen) + gcodegen.config().standby_temperature_delta.value, false, extruder_id);
+                gcode.pop_back();
+                gcode += " ;cooldown\n"; // this is a marker for GCodeProcessor, so it can supress the commands when needed
            }
+        } else {
+            // Use the value from filament settings. That one is absolute, not delta.
+            gcode += gcodegen.writer().set_temperature(filament_idle_temp.get_at(extruder_id), false, extruder_id);
+            gcode.pop_back();
+            gcode += " ;cooldown\n"; // this is a marker for GCodeProcessor, so it can supress the commands when needed
        }

-        std::string gcode = gcodegen.writer().set_temperature(temp, false, extruder_id);
-        gcode.pop_back();
-        gcode += " ;cooldown\n"; // this is a marker for GCodeProcessor, so it can supress the commands when needed
        return gcode;
    }

@@ -3985,16 +3976,6 @@ 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();
@@ -1004,7 +1004,6 @@ protected:
        size_t                                                  num_objects,
        size_t                                                  num_islands);

-    friend class OozePrevention;
    friend class Wipe;
    friend class WipeTowerIntegration;
    friend class PressureEqualizer;
@@ -120,13 +120,7 @@ const std::vector<std::string> GCodeProcessor::Reserved_Tags = {
    "@PRINT_TIME_HOUR@",
    "@PRINT_TIME_MINUTE@",
    "@PRINT_TIME_SEC@",
-    "@USED_FILAMENT_LENGTH@",
-    "@NORMAL_PRINT_TIME@",
-    "@SILENT_PRINT_TIME@",
-    "@TOTAL_WEIGHT@",
-    "@TOTAL_COST@",
-    "@TOTAL_WIPE_TOWER_COST@",
-    "@TOTAL_WIPE_TOWER_FILAMENT@"
+    "@USED_FILAMENT_LENGTH@"
 };

 const std::vector<std::string> GCodeProcessor::Reserved_Tags_compatible = {
@@ -153,13 +147,7 @@ const std::vector<std::string> GCodeProcessor::Reserved_Tags_compatible = {
    "@PRINT_TIME_HOUR@",
    "@PRINT_TIME_MINUTE@",
    "@PRINT_TIME_SEC@",
-    "@USED_FILAMENT_LENGTH@",
-    "@NORMAL_PRINT_TIME@",
-    "@SILENT_PRINT_TIME@",
-    "@TOTAL_WEIGHT@",
-    "@TOTAL_COST@",
-    "@TOTAL_WIPE_TOWER_COST@",
-    "@TOTAL_WIPE_TOWER_FILAMENT@"
+    "@USED_FILAMENT_LENGTH@"
 };


@@ -1276,22 +1264,19 @@ void GCodeProcessor::run_post_process()
        return ret;
    };

-    // Process inline placeholders (print_time_*, used_filament_length and the print statistics known only after export)
+    // Process inline placeholders (print_time_total_sec, print_time_day, print_time_hour, print_time_minute, print_time_sec and used_filament_length)
    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;

-        auto replace_tag = [&gcode_line, &processed](ETags tag, const std::string& value) {
-            const std::string& placeholder = reserved_tag(tag);
-            size_t pos = gcode_line.find(placeholder);
-            while (pos != std::string::npos) {
-                gcode_line.replace(pos, placeholder.length(), value);
-                processed = true;
-                pos = gcode_line.find(placeholder, pos + value.length());
-            }
-        };
+        const std::string& print_time_total_placeholder = reserved_tag(ETags::Print_Time_Total_Sec_Placeholder);
+        const std::string& print_time_day_placeholder = reserved_tag(ETags::Print_Time_Day_Placeholder);
+        const std::string& print_time_hour_placeholder = reserved_tag(ETags::Print_Time_Hour_Placeholder);
+        const std::string& print_time_minute_placeholder = reserved_tag(ETags::Print_Time_Minute_Placeholder);
+        const std::string& print_time_sec_placeholder = reserved_tag(ETags::Print_Time_Sec_Placeholder);
+        const std::string& used_filament_placeholder = reserved_tag(ETags::Used_Filament_Length_Placeholder);

        double print_time_total_sec = m_time_processor.machines[static_cast<size_t>(PrintEstimatedStatistics::ETimeMode::Normal)].time;
        if (print_time_total_sec < 0.0)
@@ -1304,31 +1289,70 @@ void GCodeProcessor::run_post_process()
        int print_time_minute = (day_remainder_seconds % 3600) / 60;
        int print_time_sec = day_remainder_seconds % 60;

-        double total_filament_mm = 0.0;
-        for (const auto& mm : filament_mm) {
-            total_filament_mm += mm;
+        // Replace print_time_total_sec
+        size_t pos = gcode_line.find(print_time_total_placeholder);
+        while (pos != std::string::npos) {
+            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_tag(ETags::Print_Time_Total_Sec_Placeholder, Slic3r::float_to_string_decimal_point(print_time_total_sec, 2));
-        replace_tag(ETags::Print_Time_Day_Placeholder, std::to_string(print_time_day));
-        replace_tag(ETags::Print_Time_Hour_Placeholder, std::to_string(print_time_hour));
-        replace_tag(ETags::Print_Time_Minute_Placeholder, std::to_string(print_time_minute));
-        replace_tag(ETags::Print_Time_Sec_Placeholder, std::to_string(print_time_sec));
-        replace_tag(ETags::Used_Filament_Length_Placeholder,
-                    Slic3r::float_to_string_decimal_point(total_filament_mm / 1000.0, 2)); // Convert mm to m
-        // 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_tag(ETags::Silent_Print_Time_Placeholder, is_stealth_time_estimator_enabled() ?
-                                                              get_time_dhm(PrintEstimatedStatistics::ETimeMode::Stealth) :
-                                                              short_time("N/A"));
-        const double total_cost = filament_total_cost + m_print->config().time_cost.value * print_time_total_sec / 3600.0;
-        replace_tag(ETags::Total_Weight_Placeholder, Slic3r::float_to_string_decimal_point(filament_total_g, 2));
-        replace_tag(ETags::Total_Cost_Placeholder, Slic3r::float_to_string_decimal_point(total_cost, 2));
-        replace_tag(ETags::Total_Wipe_Tower_Cost_Placeholder,
-                    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_day
+        pos = gcode_line.find(print_time_day_placeholder);
+        while (pos != std::string::npos) {
+            char buf[64];
+            sprintf(buf, "%d", print_time_day);
+            gcode_line.replace(pos, print_time_day_placeholder.length(), buf);
+            processed = true;
+            pos = gcode_line.find(print_time_day_placeholder, pos + strlen(buf));
+        }
+
+        // Replace print_time_hour
+        pos = gcode_line.find(print_time_hour_placeholder);
+        while (pos != std::string::npos) {
+            char buf[64];
+            sprintf(buf, "%d", print_time_hour);
+            gcode_line.replace(pos, print_time_hour_placeholder.length(), buf);
+            processed = true;
+            pos = gcode_line.find(print_time_hour_placeholder, pos + strlen(buf));
+        }
+
+        // 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;
    };
@@ -601,12 +601,6 @@ 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)]; }
@@ -1276,13 +1276,6 @@ void ToolOrdering::collect_extruder_statistics(bool prime_multi_material)
        sort_remove_duplicates(m_all_printing_extruders);
    }

-    m_last_layer_per_extruder.clear();
-    for (const LayerTools& lt : m_layer_tools) {
-        for (unsigned int ext : lt.extruders) {
-            m_last_layer_per_extruder[ext] = lt.print_z;
-        }
-    }
-
    if (prime_multi_material && ! m_all_printing_extruders.empty()) {
        // Reorder m_all_printing_extruders in the sequence they will be primed, the last one will be m_first_printing_extruder.
        // Then set m_first_printing_extruder to the 1st extruder primed.
@@ -3671,11 +3664,5 @@ int WipingExtrusions::get_support_interface_extruder_overrides(const PrintObject
    return -1;
 }

-bool ToolOrdering::is_last_extrusion_layer(coordf_t print_z, unsigned int extruder_id) const
-{
-    auto it = m_last_layer_per_extruder.find(extruder_id);
-    if (it == m_last_layer_per_extruder.end())
-        return true;
-    return print_z >= it->second - EPSILON;
-}
+
 } // namespace Slic3r
@@ -370,7 +370,6 @@ public:
                                                  std::vector<int> & initial_filaments);

    bool                has_non_support_filament(const PrintConfig &config);
-    bool                is_last_extrusion_layer(coordf_t print_z, unsigned int extruder_id) const;

 private:
    void				initialize_layers(std::vector<coordf_t> &zs);
@@ -414,8 +413,6 @@ private:
    // which keeps every legacy per-object code path bit-identical (loops over an empty map are
    // no-ops; downstream emission falls through to the per-object branch).
    std::map<unsigned int, std::map<LayerTools::MixedSubLayerGroup::VolumeKey, std::vector<size_t>>> m_gradient_volume_layers;
-    // Map: extruder_id -> print_z (z coordinate) of the last layer it is used on
-    std::map<unsigned int, coordf_t> m_last_layer_per_extruder;
    const PrintObject*         m_print_object_ptr = nullptr;
    Print*                     m_print;
    bool                       m_sorted = false;
@@ -211,35 +211,6 @@ bool decode_colored_png(const ReadBuf &in_buf, ImageColorscale &out_img)
    return decode_colored_png(stream, out_img);
 }

-bool is_decodable_8bit_png(const ReadBuf &pngbuf)
-{
-    static const constexpr int PNG_SIG_BYTES = 8;
-
-    struct ReadBufStream stream{pngbuf};
-    std::vector<png_byte> sig(PNG_SIG_BYTES, 0);
-    stream.read(sig.data(), PNG_SIG_BYTES);
-    if (!png_check_sig(sig.data(), PNG_SIG_BYTES))
-        return false;
-
-    PNGDescr dsc;
-    dsc.png = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
-    if (!dsc.png)
-        return false;
-    dsc.info = png_create_info_struct(dsc.png);
-    if (!dsc.info)
-        return false;
-
-    if (!png_read_header_guarded(dsc.png, dsc.info, &stream, PNG_SIG_BYTES))
-        return false;
-
-    const size_t color_type = png_get_color_type(dsc.png, dsc.info);
-    const size_t bit_depth  = png_get_bit_depth(dsc.png, dsc.info);
-    const bool   grey       = color_type == PNG_COLOR_TYPE_GRAY;
-    const bool   colour     = color_type == PNG_COLOR_TYPE_RGB || color_type == PNG_COLOR_TYPE_RGB_ALPHA;
-    return png_get_image_width(dsc.png, dsc.info) > 0 && png_get_image_height(dsc.png, dsc.info) > 0 &&
-           bit_depth == 8 && (grey || colour);
-}
-

 // Down to earth function to store a packed RGB image to file. Mostly useful for debugging purposes.
 // Based on https://www.lemoda.net/c/write-png/
@@ -50,9 +50,6 @@ struct ReadBuf { const void *buf = nullptr; const size_t sz = 0; };

 bool is_png(const ReadBuf &pngbuf);

-// True if decode_png() or decode_colored_png() would accept these bytes, judged from the header alone.
-bool is_decodable_8bit_png(const ReadBuf &pngbuf);
-
 struct ReadBufStream: public IStream {
    const ReadBuf &rbuf_ref;
    size_t pos = 0;
@@ -62,12 +62,7 @@ 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;

@@ -577,8 +572,7 @@ 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 &&
-                    !perimeter_generator.outer_walls_first_for_brim())
+                if (thin_wall_hole && perimeter_generator.config->wall_sequence != WallSequence::OuterInner)
                    std::reverse(extrusion_coll.entities.begin(), extrusion_coll.entities.end());
            }
            else {
@@ -1696,24 +1690,13 @@ 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, a
-                // narrow wall hole none for an inner wall, the room the next loop is offset by below.
+                // ORCA: a thin wall hole has no room for gap fill or an inner wall anywhere beside its outer wall.
                if (i == 0 && ! holes[0].empty()) {
-                    auto reach = [&last](double room) {
-                        return to_polygons(offset2_ex(last, -float(room), float(room) + float(SCALED_EPSILON)));
-                    };
-                    auto out_of_reach = [](const Polygon &hole, const Polygons &reach) {
-                        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);
-                    }
+                    const float    room  = float(0.5 * (ext_perimeter_spacing2 + gap_fill_min_width));
+                    const Polygons reach = to_polygons(offset2_ex(last, -room, room + float(SCALED_EPSILON)));
+                    for (PerimeterGeneratorLoop &hole : holes[0])
+                        hole.is_thin_wall_hole = intersection_pl(Polylines{ hole.polygon.split_at_first_point() },
+                            ClipperUtils::clip_clipper_polygons_with_subject_bbox(reach, get_extents(hole.polygon).inflated(SCALED_EPSILON))).empty();
                }

                //BBS: refer to superslicer
@@ -1852,16 +1835,18 @@ 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;
-            // Orca: a contour with only a narrow wall hole beside it has nothing to sandwich, and prints the hole first,
-            // then the contour, then the gap fill between them, as Arachne does.
-            const PerimeterGeneratorLoops &island_loops = contours.front();
-            const bool narrow_wall_hole_island = island_loops.size() == 1 && island_loops.front().children.size() == 1 &&
-                                                 island_loops.front().children.front().is_narrow_wall_hole;
-            if (is_outer_wall_first || this->outer_walls_first_for_brim())
+            if (is_outer_wall_first ||
+                //BBS: always print outer wall first when there indeed has brim.
+                // btLeadingEdgeOnly is an outer brim too (a belt brim at the part's first contact).
+                (this->layer_id == 0 &&
+                    (this->object_config->brim_type == BrimType::btOuterOnly ||
+                     this->object_config->brim_type == BrimType::btLeadingEdgeOnly) &&
+                    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 && !narrow_wall_hole_island){
+            else if ((this->config->wall_sequence == WallSequence::InnerOuterInner) && layer_id > 0){
                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.
@@ -2427,25 +2412,11 @@ std::vector<PerimeterGeneratorArachneExtrusion> reorderPerimetersByProximity(std

    // Function to reorder perimeters starting from a given reference index
    auto reorderFromReference = [&](int referenceIndex) {
-        // Find first level touching perimeters. The odd centre line of a wall too narrow for two inner walls is shared
-        // 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};
-        std::vector<int> firstLevelTouchingIndices;
-        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; });
+        std::unordered_set<int> firstLevelIndices;
+        firstLevelIndices.insert(referenceIndex);
+
+        // Find first level touching perimeters
+        std::vector<int> firstLevelTouchingIndices = findAllTouchingPerimeters(entities, firstLevelIndices, threshold_external, threshold_internal, 1);
        // 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
@@ -2456,10 +2427,8 @@ std::vector<PerimeterGeneratorArachneExtrusion> reorderPerimetersByProximity(std
            std::iter_swap(maxIt, firstLevelTouchingIndices.end() - 1);
        }
        // Insert first level perimeters into reordered list
-        for (int idx : outerIndices) {
-            reordered.push_back(entities[idx]);
-            includedIndices.insert(idx);
-        }
+        reordered.push_back(entities[referenceIndex]);
+        includedIndices.insert(referenceIndex);

        for (int idx : firstLevelTouchingIndices) {
            if (includedIndices.count(idx) == 0) {
@@ -2788,7 +2757,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->outer_walls_first_for_brim();
+            	this->config->wall_sequence == WallSequence::OuterInner;
        }
        if (is_outer_wall_first) {
            start_perimeter = 0;
@@ -3073,16 +3042,6 @@ 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);
@@ -164,8 +164,6 @@ 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);
@@ -185,10 +183,6 @@ 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
@@ -2293,7 +2293,6 @@ 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);
@@ -4511,6 +4511,53 @@ static void warn_ambiguous_filament_id_match(const PresetCollection &filaments,
                                   << "\", also matches " << others;
 }

+// Orca: resolve a compatible system preset from a printer-reported filament type. Prefers an exact
+// "Generic <type>" match, then the longest generic whose filament_type appears as a whole word in
+// the reported type (e.g. "ASA" in "ASA Sparkle"). On success `generic_name_out` holds the
+// "Generic <...>" name used for compatibility messages. Shared by the known-filament_id lookup and
+// the data-bearing-but-unmapped tray path so both pick the same preset.
+static PresetCollection::Iterator find_generic_preset_for_type(PresetCollection &filaments, const std::string &filament_type, std::string &generic_name_out)
+{
+    if (filament_type.empty())
+        return filaments.end();
+    const std::string generic_name = "Generic " + filament_type;
+    auto iter = std::find_if(filaments.begin(), filaments.end(), [&generic_name](const Preset &f) {
+        return f.is_compatible && f.is_system && boost::algorithm::starts_with(f.name, generic_name);
+    });
+    if (iter != filaments.end()) {
+        generic_name_out = generic_name;
+        return iter;
+    }
+    // Similarity fallback: find a generic preset whose filament_type
+    // appears as a whole word in the reported type (e.g. "ASA" in "ASA Sparkle").
+    auto upper_type = boost::to_upper_copy(filament_type);
+    auto contains_word = [](const std::string& haystack, const std::string& needle) {
+        auto pos = haystack.find(needle);
+        while (pos != std::string::npos) {
+            bool start_ok = (pos == 0 || !std::isalnum(static_cast<unsigned char>(haystack[pos - 1])));
+            bool end_ok   = (pos + needle.size() >= haystack.size() ||
+                             !std::isalnum(static_cast<unsigned char>(haystack[pos + needle.size()])));
+            if (start_ok && end_ok)
+                return true;
+            pos = haystack.find(needle, pos + 1);
+        }
+        return false;
+    };
+    // Find the longest-matching preset type to prefer e.g. "PA-CF" over "PA".
+    size_t best_len = 0;
+    for (auto it = filaments.begin(); it != filaments.end(); ++it) {
+        if (!it->is_compatible || !it->is_system || !boost::algorithm::starts_with(it->name, "Generic "))
+            continue;
+        auto preset_type = boost::to_upper_copy(it->config.opt_string("filament_type", 0u));
+        if (preset_type.size() > best_len && contains_word(upper_type, preset_type)) {
+            iter = it;
+            best_len = preset_type.size();
+            generic_name_out = "Generic " + it->config.opt_string("filament_type", 0u);
+        }
+    }
+    return iter;
+}
+
 void PresetBundle::get_ams_cobox_infos(AMSComboInfo& combox_info)
 {
    combox_info.clear();
@@ -4566,7 +4613,9 @@ void PresetBundle::get_ams_cobox_infos(AMSComboInfo& combox_info)

 unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfig *,std::string>> &unknowns, bool use_map, std::map<int, AMSMapInfo> &maps, bool enable_append, MergeFilamentInfo &merge_info, bool color_only)
 {
-    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "use_map:" << use_map << " enable_append:" << enable_append;
+    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": use_map %1% enable_append %2% color_only %3% start_presets %4% start_colors %5%")
+        % use_map % enable_append % color_only % this->filament_presets.size()
+        % project_config.option<ConfigOptionStrings>("filament_colour")->values.size();
    std::vector<std::string> ams_filament_presets;
    std::vector<std::string> ams_filament_colors;
    std::vector<std::string> ams_filament_color_types;
@@ -4578,6 +4627,10 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
        bool valid{false};
        bool is_map{false};
        bool is_placeholder{false};
+        // Orca: set for a tray that reports filament data (type and/or loaded flag) but carries
+        // no preset id. It is not `valid` (no id to map through), yet it still holds a real spool
+        // and is eligible for the same append step as a mapped tray.
+        bool has_reported_data{false};
        std::string filament_color  = "";
        std::string filament_color_type = "";
        std::string filament_preset = "";
@@ -4591,12 +4644,32 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
        auto filament_id = ams.opt_string("filament_id", 0u);
        auto filament_color = ams.opt_string("filament_colour", 0u);
        auto filament_color_type = ams.opt_string("filament_colour_type", 0u);
+        auto filament_type = ams.opt_string("filament_type", 0u);
+        auto filament_exist = ams.has("filament_exist") && ams.opt_bool("filament_exist", 0u);
        auto filament_changed = !ams.has("filament_changed") || ams.opt_bool("filament_changed");
        auto filament_multi_color = ams.opt<ConfigOptionStrings>("filament_multi_colour")->values;
        auto ams_id     = ams.opt_string("ams_id", 0u);
        auto slot_id    = ams.opt_string("slot_id", 0u);
        auto is_placeholder = ams.has("filament_slot_placeholder") && ams.opt_bool("filament_slot_placeholder", 0u);
-        ams_infos.push_back({filament_id.empty() ? false : true, false, is_placeholder, filament_color});
+        // Real reported filament data: the device named a type or flagged the slot loaded. A
+        // topology-only synthetic virtual tray carries neither, so it must not become a filament.
+        bool has_reported_data = !is_placeholder && filament_id.empty() && (!filament_type.empty() || filament_exist);
+        AmsInfo ams_info;
+        ams_info.valid             = !filament_id.empty();
+        ams_info.is_placeholder    = is_placeholder;
+        ams_info.has_reported_data = has_reported_data;
+        ams_info.filament_color    = filament_color;
+        // Only the append path of a data-bearing, id-less tray reads these; the known-id path keeps
+        // taking its color and color type from ams_filament_colors/ams_filament_color_types.
+        if (has_reported_data) {
+            if (ams_info.filament_color.empty())
+                ams_info.filament_color = "#CECECE";
+            ams_info.filament_color_type = filament_color_type.empty() ? "1" : filament_color_type;
+        }
+        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": entry %1% ams_id %2% slot_id %3% filament_id %4% type %5% color %6% valid %7% placeholder %8% reported_data %9% changed %10%")
+            % index % ams_id % slot_id % filament_id % filament_type % filament_color
+            % (!filament_id.empty()) % is_placeholder % has_reported_data % filament_changed;
+        ams_infos.push_back(std::move(ams_info));
        AMSMapInfo temp = {ams_id, slot_id};
        ams_array_maps.push_back(temp);
        index++;
@@ -4607,20 +4680,55 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                        maps.erase(j);
                    }
                }
-                ams_filament_presets.push_back("Generic PLA");//for unknow matieral
-                auto default_unknown_color = "#CECECE";
-                ams_filament_colors.push_back(default_unknown_color);
-                ams_filament_color_types.push_back("1");
-                if (filament_multi_color.size() == 0) {
-                    filament_multi_color.push_back(default_unknown_color);
-                }
-                ams_multi_color_filment.push_back(filament_multi_color);
-            } else if (is_placeholder) {
-                // Orca: push placeholders to keep index alignment with ams_infos
+            }
+            if (is_placeholder) {
+                // Orca: an empty AMS slot is a placeholder, not a filament - never synthesize a
+                // preset for it. Kept here only to keep index alignment with ams_infos; the sync
+                // drops it so no filament slot is created or retained for an empty tray.
                ams_filament_presets.push_back("");
                ams_filament_colors.push_back("");
                ams_filament_color_types.push_back("");
                ams_multi_color_filment.push_back({});
+            } else if (use_map) {
+                if (has_reported_data) {
+                    // Orca: the tray reports a filament but no preset id, so it never reaches the
+                    // filament_id lookup. Resolve the same generic preset the id path would pick
+                    // from the reported type and keep the reported color; the append step below (if
+                    // enabled) then turns it into a sidebar filament. Without a generic match the
+                    // slot is dropped rather than invented, exactly like an empty tray.
+                    std::string resolved_generic;
+                    auto generic = find_generic_preset_for_type(filaments, filament_type, resolved_generic);
+                    if (generic == filaments.end()) {
+                        // Reported loaded but no usable type: fall back to the first compatible
+                        // generic, matching the id path's fallback for an unknown model.
+                        generic = std::find_if(filaments.begin(), filaments.end(), [](const Preset &f) {
+                            return f.is_compatible && f.is_system && boost::algorithm::starts_with(f.name, "Generic ");
+                        });
+                    }
+                    if (generic != filaments.end()) {
+                        auto append_color = filament_color.empty() ? std::string("#CECECE") : filament_color;
+                        ams_filament_presets.push_back(generic->name);
+                        ams_filament_colors.push_back(append_color);
+                        ams_filament_color_types.push_back(filament_color_type.empty() ? "1" : filament_color_type);
+                        if (filament_multi_color.size() == 0)
+                            filament_multi_color.push_back(append_color);
+                        ams_multi_color_filment.push_back(filament_multi_color);
+                        continue;
+                    }
+                    ams_filament_presets.push_back("");
+                    ams_filament_colors.push_back("");
+                    ams_filament_color_types.push_back("");
+                    ams_multi_color_filment.push_back({});
+                } else {
+                    ams_filament_presets.push_back("Generic PLA");//for unknow matieral
+                    auto default_unknown_color = "#CECECE";
+                    ams_filament_colors.push_back(default_unknown_color);
+                    ams_filament_color_types.push_back("1");
+                    if (filament_multi_color.size() == 0) {
+                        filament_multi_color.push_back(default_unknown_color);
+                    }
+                    ams_multi_color_filment.push_back(filament_multi_color);
+                }
            }
            continue;
        }
@@ -4632,49 +4740,19 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
            continue;
        }
        bool has_type = false;
-        auto filament_type = ams.opt_string("filament_type", 0u);
        auto iter = std::find_if(filaments.begin(), filaments.end(), [this, &filament_id, &has_type, filament_type](auto &f) {
            has_type |= f.config.opt_string("filament_type", 0u) == filament_type;
            return f.is_compatible && filaments.get_preset_base(f) == &f && f.filament_id == filament_id; });
        warn_ambiguous_filament_id_match(filaments, iter, filament_id);
        if (iter == filaments.end()) {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": filament_id %1% not found or system or compatible") % filament_id;
-            if (!filament_type.empty()) {
-                auto original_type = filament_type;
+            std::string resolved_generic;
+            auto        generic = find_generic_preset_for_type(filaments, filament_type, resolved_generic);
+            if (!filament_type.empty())
                filament_type = "Generic " + filament_type;
-                iter = std::find_if(filaments.begin(), filaments.end(), [&filament_type](auto &f) {
-                    return f.is_compatible && f.is_system
-                        && boost::algorithm::starts_with(f.name, filament_type);
-                });
-                if (iter == filaments.end()) {
-                    // Similarity fallback: find a generic preset whose filament_type
-                    // appears as a whole word in the AMS type (e.g. "ASA" in "ASA Sparkle").
-                    auto upper_type = boost::to_upper_copy(original_type);
-                    auto contains_word = [](const std::string& haystack, const std::string& needle) {
-                        auto pos = haystack.find(needle);
-                        while (pos != std::string::npos) {
-                            bool start_ok = (pos == 0 || !std::isalnum(static_cast<unsigned char>(haystack[pos - 1])));
-                            bool end_ok   = (pos + needle.size() >= haystack.size() ||
-                                             !std::isalnum(static_cast<unsigned char>(haystack[pos + needle.size()])));
-                            if (start_ok && end_ok)
-                                return true;
-                            pos = haystack.find(needle, pos + 1);
-                        }
-                        return false;
-                    };
-                    // Find the longest-matching preset type to prefer e.g. "PA-CF" over "PA".
-                    size_t best_len = 0;
-                    for (auto it = filaments.begin(); it != filaments.end(); ++it) {
-                        if (!it->is_compatible || !it->is_system || !boost::algorithm::starts_with(it->name, "Generic "))
-                            continue;
-                        auto preset_type = boost::to_upper_copy(it->config.opt_string("filament_type", 0u));
-                        if (preset_type.size() > best_len && contains_word(upper_type, preset_type)) {
-                            iter = it;
-                            best_len = preset_type.size();
-                            filament_type = "Generic " + it->config.opt_string("filament_type", 0u);
-                        }
-                    }
-                }
+            if (generic != filaments.end()) {
+                iter            = generic;
+                filament_type   = resolved_generic;
            }
            if (iter == filaments.end()) {
                // Prefer old selection
@@ -4834,6 +4912,8 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
            }
        }

+        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": color_only mapped_any %1% maps %2% entries %3%")
+            % mapped_any % maps.size() % ams_infos.size();
        filament_color->values = exist_colors;
        ams_multi_color_filment = exist_multi_color_filment;
        merge_info.merges.clear();
@@ -4893,13 +4973,18 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
            }
        }
        for (size_t i = 0; i < ams_infos.size(); i++) {// check append
-            if (ams_infos[i].valid) {
+            // A mapped tray (valid id) and a data-bearing tray without an id both append the same
+            // way; only a tray with neither contributes nothing.
+            if (ams_infos[i].valid || ams_infos[i].has_reported_data) {
                if (i >= ams_filament_presets.size()) {
                    BOOST_LOG_TRIVIAL(error) << __FUNCTION__ << "check error: array bound (check append)";
                    continue;
                }
                ams_infos[i].filament_preset = ams_filament_presets[i];
                ams_infos[i].mutli_filament_color = ams_multi_color_filment[i];
+                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": entry %1% mapped %2% preset %3% color %4% valid %5% reported_data %6%")
+                    % i % ams_infos[i].is_map % ams_infos[i].filament_preset % ams_infos[i].filament_color
+                    % ams_infos[i].valid % ams_infos[i].has_reported_data;
                if (!ams_infos[i].is_map) {
                    need_append_colors.emplace_back(ams_infos[i]);
                    ams_filament_colors[i]     = "";
@@ -4909,6 +4994,7 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                }
            }
            else {
+                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": entry %1% dropped (no valid id or reported data)") % i;
                ams_filament_colors[i]     = "";
                ams_filament_color_types[i] = "";
                ams_filament_presets[i]    = "";
@@ -4926,7 +5012,7 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                                                     [](std::vector<std::string> &value) { return value.empty(); }),
                                      ams_multi_color_filment.end());
        if (need_append_colors.size() > 0 && enable_append) {
-            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "need_append_colors.size() > 0 && enable_append";
+            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": append candidates %1% (start existing %2%)") % need_append_colors.size() % exist_filament_presets.size();
            auto get_idx_in_array = [](std::vector<std::string> &presets, std::vector<std::string> &colors, const std::string &preset, const std::string &color) -> int {
                for (size_t i = 0; i < presets.size(); i++) {
                    if (presets[i] == preset && colors[i] == color) {
@@ -4937,17 +5023,22 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
            };
            for (size_t i = 0; i < need_append_colors.size(); i++){
                if (exist_filament_presets.size() >= MAXIMUM_AMS_SYNC_FILAMENT_NUMBER){
+                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": append capped at %1%, %2% candidate(s) left") % MAXIMUM_AMS_SYNC_FILAMENT_NUMBER % (need_append_colors.size() - i);
                    break;
                }
                auto idx = get_idx_in_array(exist_filament_presets, exist_colors, need_append_colors[i].filament_preset, need_append_colors[i].filament_color);
                if (idx >= 0) {
+                    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": append dedup preset %1% color %2% already at %3%") % need_append_colors[i].filament_preset % need_append_colors[i].filament_color % idx;
                    continue;
                }
                exist_filament_presets.push_back(need_append_colors[i].filament_preset);
                exist_colors.push_back(need_append_colors[i].filament_color);
                exist_color_types.push_back(need_append_colors[i].filament_color_type);
                exist_multi_color_filment.push_back(need_append_colors[i].mutli_filament_color);
+                BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": appended preset %1% color %2% type %3% -> slot %4%") % need_append_colors[i].filament_preset % need_append_colors[i].filament_color % need_append_colors[i].filament_color_type % (exist_filament_presets.size() - 1);
            }
+        } else {
+            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": append skipped candidates %1% enable_append %2%") % need_append_colors.size() % enable_append;
        }
        filament_color->values = exist_colors;
        filament_color_type->values = exist_color_types;
@@ -4984,6 +5075,10 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
                    result_multi_colors.push_back(
                        i < ams_multi_color_filment.size() ? ams_multi_color_filment[i]
                                                           : std::vector<std::string>{ams_filament_colors[i]});
+                } else if (i < ams_infos.size() && ams_infos[i].is_placeholder) {
+                    // Orca: an empty AMS slot is a placeholder, not a filament, so drop it instead of
+                    // keeping or filling a slot for it. The device AMS panel still shows the empty tray.
+                    continue;
                } else if (i < exist_presets.size()) {
                    // Empty tray or beyond tray count: keep existing filament
                    result_colors.push_back(exist_colors[i]);
@@ -5008,8 +5103,8 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
            filament_color_type->values = result_color_types;
            this->filament_presets      = result_presets;
            ams_multi_color_filment     = result_multi_colors;
-            filament_map->values.resize(total, 1);
-            filament_volume_map->values.resize(total, static_cast<int>(NozzleVolumeType::nvtStandard));
+            filament_map->values.resize(result_presets.size(), 1);
+            filament_volume_map->values.resize(result_presets.size(), static_cast<int>(NozzleVolumeType::nvtStandard));
        } else {
            // BBL: existing wholesale replace
            filament_color->values = ams_filament_colors;
@@ -5059,7 +5154,7 @@ unsigned int PresetBundle::sync_ams_list(std::vector<std::pair<DynamicPrintConfi
    // Update ams_multi_color_filment
    update_filament_multi_color();
    update_multi_material_filament_presets();
-    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << "finish sync ams list";
+    BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << boost::format(": finish sync ams list, end_presets %1% end_colors %2%") % this->filament_presets.size() % filament_color->values.size();
    return this->filament_presets.size();
 }

@@ -5138,6 +5233,20 @@ std::vector<std::vector<DynamicPrintConfig>> PresetBundle::get_extruder_filament
    if (extruder_nums > 1) {
        filament_infos.resize(extruder_nums, std::vector<DynamicPrintConfig>());
        for (auto ams_item : filament_ams_list) {
+            // A generic slot carries the extruder it actually belongs to, so it lands in that
+            // extruder's bucket instead of the legacy left/right pair. Bambu entries (and anything
+            // without the field) keep the existing 0x10000 key convention.
+            const bool has_extruder_id = ams_item.second.has("device_tray_extruder_id");
+            const int  entry_extruder  = has_extruder_id ? ams_item.second.opt_int("device_tray_extruder_id") : -1;
+            if (has_extruder_id) {
+                if (entry_extruder >= 0 && entry_extruder < extruder_nums) {
+                    // Drop the transient association before the config reaches the slicing pipeline.
+                    DynamicPrintConfig entry = ams_item.second;
+                    entry.erase("device_tray_extruder_id");
+                    filament_infos[entry_extruder].push_back(std::move(entry));
+                }
+                continue;
+            }
            if (ams_item.first & 0x10000) { // right
                filament_infos[1].push_back(ams_item.second);
            } else { // left
@@ -17,7 +17,6 @@
 #include "I18N.hpp"
 #include "Layer.hpp"
 #include "MutablePolygon.hpp"
-#include "PerimeterGenerator.hpp"
 #include "PrintBase.hpp"
 #include "PrintConfig.hpp"
 #include "SLA/IndexedMesh.hpp"
@@ -859,10 +858,11 @@ void PrintObject::contour_z()
    BOOST_LOG_TRIVIAL(debug) << "Contouring in parallel - start";

    TriangleMesh mesh = this->m_model_object->raw_mesh();
-    // A PrintObject groups the instances that share their whole transformation but the XY shift: an
-    // instance rotated, scaled or mirrored differently is a PrintObject of its own. So the first
-    // instance stands for all of them.
-    const ModelInstance *inst = m_instances.front().model_instance;
+    if (m_model_object->instances.size() != 1) {
+        throw RuntimeError("ContourZ: unexpected number of instances");
+    }
+
+    ModelInstance *inst = m_model_object->instances.front();
    Point                    center_offset = this->center_offset();
    Geometry::Transformation trans = inst->get_transformation();

@@ -1465,13 +1465,15 @@ 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" || opt_key == "brim_width") {
-                // Regenerate the walls when the brim starts or stops putting the first layer's outer walls first.
-                auto outer_walls_first = [](const ConfigOptionResolver &config) {
-                    return brim_puts_outer_walls_first(config.option<ConfigOptionEnum<BrimType>>("brim_type")->value,
-                                                       config.option<ConfigOptionFloat>("brim_width")->value);
-                };
-                if (outer_walls_first(old_config) != outer_walls_first(new_config))
+            if (opt_key == "brim_type") {
+                const auto* old_brim_type = old_config.option<ConfigOptionEnum<BrimType>>(opt_key);
+                const auto* new_brim_type = new_config.option<ConfigOptionEnum<BrimType>>(opt_key);
+                //BBS: When switch to manual brim, the object must have brim, then re-generate perimeter
+                //to make the wall order of first layer to be outer-first
+                // btLeadingEdgeOnly is printed as an outer brim (Brim.cpp, BeltBrim.cpp), so it
+                // takes part in the same first-layer wall order rule.
+                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 (
@@ -707,10 +707,8 @@ void tree_supports_generate_paths(
                                            false);
        }
        if (eec) {
-            if (!eec->empty()) {
-                std::reverse(eec->entities.begin(), eec->entities.end());
-                dst.emplace_back(eec.release());
-            }
+            std::reverse(eec->entities.begin(), eec->entities.end());
+            dst.emplace_back(eec.release());
        }
    }
 }
@@ -1827,7 +1825,12 @@ 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)) {
-                    tree_supports_generate_paths(base_layer.extrusions, base_layer.polygons_to_extrude(), flow, support_params);
+                    // Orca: A special case for the hollow Organic supports
+                    // 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)
@@ -2149,9 +2149,7 @@ 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:
@@ -2203,7 +2201,7 @@ void TreeSupport::draw_circles()
                size_t           first_base_roof_area = 0;
                bool             floor_interface_as_base = false;
                bool has_circle_node = false;
-                ExPolygons extra_wall_areas;
+                bool need_extra_wall = false;
                ExPolygons collision_sharp_tails;
                ExPolygons collision_base;
                auto             get_collision = [&](bool sharp_tail) -> ExPolygons             &{
@@ -2281,6 +2279,7 @@ 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.
@@ -2295,10 +2294,6 @@ 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 &&
@@ -2535,8 +2530,7 @@ 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 = !area_groups.back().need_infill &&
-                        !extra_wall_areas.empty() && overlaps({expoly}, extra_wall_areas);
+                    area_groups.back().need_extra_wall = need_extra_wall && !area_groups.back().need_infill;
                }
                for (size_t roof_idx = 0; roof_idx < ts_layer->roof_areas.size(); ++roof_idx) {
                    auto &expoly = ts_layer->roof_areas[roof_idx];
@@ -3439,6 +3433,11 @@ 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;
@@ -3448,17 +3447,20 @@ 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;
@@ -3477,6 +3479,9 @@ 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;
                        }
                    }
@@ -3484,6 +3489,13 @@ 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;
+                        }
+                    }
                }
            }
        }
@@ -135,6 +135,7 @@ 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
@@ -283,7 +283,7 @@ bool height_texture_has_color(const TextureDisplacementLayer &layer)
    return decode_height_texture(layer).has_color();
 }

-DecodedHeightTexture decode_height_texture(const TextureDisplacementLayer &layer, bool keep_decoded)
+DecodedHeightTexture decode_height_texture(const TextureDisplacementLayer &layer)
 {
    DecodedHeightTexture result;
    if (layer.empty())
@@ -351,15 +351,13 @@ DecodedHeightTexture decode_height_texture(const TextureDisplacementLayer &layer
                }
        }

-        if (keep_decoded) {
-            std::lock_guard<std::mutex> lock(g_decoded_texture_cache.mutex);
-            // Opportunistically drop entries for image_data that no longer exists anywhere, so the
-            // cache doesn't grow without bound across many add/remove-texture cycles in a long session.
-            auto &entries = g_decoded_texture_cache.entries;
-            for (auto it = entries.begin(); it != entries.end();)
-                it = it->second.first.expired() ? entries.erase(it) : std::next(it);
-            entries[key] = { std::weak_ptr<const std::vector<unsigned char>>(layer.image_data), result };
-        }
+        std::lock_guard<std::mutex> lock(g_decoded_texture_cache.mutex);
+        // Opportunistically drop entries for image_data that no longer exists anywhere, so the
+        // cache doesn't grow without bound across many add/remove-texture cycles in a long session.
+        auto &entries = g_decoded_texture_cache.entries;
+        for (auto it = entries.begin(); it != entries.end();)
+            it = it->second.first.expired() ? entries.erase(it) : std::next(it);
+        entries[key] = { std::weak_ptr<const std::vector<unsigned char>>(layer.image_data), result };
    }

    // The image-adjustment panel's live edits, on top of the decode and before the smoothing. Before,
@@ -599,9 +599,8 @@ DecodedHeightTexture downscale_height_texture(const DecodedHeightTexture &src, i
 // colour PNGs are accepted; for a colour source the height is its luminance, using the same
 // coefficients wxImage::ConvertToGreyscale() uses, so a texture imported as colour displaces exactly
 // as it did when the importer flattened it to grey on the way in. Returns an empty
-// DecodedHeightTexture if image_data is empty or is not a PNG at all. keep_decoded = false leaves the
-// result out of the decode cache, for one-off reads such as a picker thumbnail that must not hold full-size pixels.
-DecodedHeightTexture decode_height_texture(const TextureDisplacementLayer &layer, bool keep_decoded = true);
+// DecodedHeightTexture if image_data is empty or is not a PNG at all.
+DecodedHeightTexture decode_height_texture(const TextureDisplacementLayer &layer);

 // decode_height_texture(layer).has_color(), answered from the decode cache rather than from a copy of the
 // texture - cheap enough to ask every frame. Smoothing does not change it, so the raw decode is what is read.
@@ -842,13 +842,6 @@ void load_string_file(const boost::filesystem::path& p, std::string& str);

 bool check_layer_id_pattern(const std::string& pattern, int layer_id);

-// On Windows, return an equivalent path carrying the extended-length ("\\?\" / "\\?\UNC\")
-// prefix so the Win32 APIs accept it past MAX_PATH even when LongPathsEnabled is off. The path
-// is made absolute and lexically normalized first, because the prefix disables normalisation.
-// A path that is already extended (or a device path) is returned unchanged; on other platforms,
-// or when an absolute path cannot be formed, the input is returned unchanged.
-boost::filesystem::path extended_path(const boost::filesystem::path& path);
-
 } // namespace Slic3r

 #if WIN32
@@ -17,7 +17,6 @@

 #if defined(_MSC_VER) || defined(__MINGW64__)
 #include "boost/nowide/cstdio.hpp"
-#include "boost/nowide/convert.hpp"
 #endif

 #include "I18N.hpp"
@@ -63,11 +62,7 @@ bool open_zip(mz_zip_archive *zip, const char *fname, bool isread)

    FILE *f = nullptr;
 #if defined(_MSC_VER) || defined(__MINGW64__)
-    // fname is UTF-8 (the nowide contract). Route it through the shared extended-path helper so an
-    // archive stored past MAX_PATH opens even with LongPathsEnabled off.
-    const std::wstring wide_path = boost::nowide::widen(fname);
-    const std::string  extended  = boost::nowide::narrow(Slic3r::extended_path(boost::filesystem::path(wide_path)).wstring());
-    f = boost::nowide::fopen(extended.c_str(), mode);
+    f = boost::nowide::fopen(fname, mode);
 #elif defined(__GNUC__) && defined(_LARGEFILE64_SOURCE)
    f = fopen64(fname, mode);
 #else
@@ -106,14 +101,6 @@ bool close_zip(mz_zip_archive *zip, bool isread)
    }
    return ret;
 }
-
-#ifdef WIN32
-// mz_file_write_func writing an extracted entry into an already-open FILE*.
-size_t mz_write_to_cfile(void *opaque, mz_uint64 /*file_ofs*/, const void *buffer, size_t size)
-{
-    return std::fwrite(buffer, 1, size, static_cast<FILE *>(opaque));
-}
-#endif
 }

 bool open_zip_reader(mz_zip_archive *zip, const std::string &fname)
@@ -129,36 +116,6 @@ bool open_zip_writer(mz_zip_archive *zip, const std::string &fname)
 bool close_zip_reader(mz_zip_archive *zip) { return close_zip(zip, true); }
 bool close_zip_writer(mz_zip_archive *zip) { return close_zip(zip, false); }

-bool extract_zip_entry_to_file(mz_zip_archive *zip, mz_uint file_index, const boost::filesystem::path &dest_path)
-{
-    if (!zip)
-        return false;
-#ifdef WIN32
-    // Open the destination ourselves with a Windows extended-length path: miniz's narrow
-    // extract_to_file cannot be relied on past MAX_PATH with LongPathsEnabled off, and its wide
-    // variant takes a plain (unprefixed) path and a text-mode stream. This keeps the write binary.
-    FILE *file = ::_wfopen(Slic3r::extended_path(dest_path).wstring().c_str(), L"wb");
-    if (!file) {
-        zip->m_last_error = MZ_ZIP_FILE_OPEN_FAILED;
-        return false;
-    }
-
-    const bool written = mz_zip_reader_extract_to_callback(zip, file_index, mz_write_to_cfile, file, 0) != 0;
-    const bool closed  = std::fclose(file) == 0;
-    if (!written || !closed) {
-        if (written && !closed)
-            zip->m_last_error = MZ_ZIP_FILE_CLOSE_FAILED;
-        // Drop the partial entry rather than leave a truncated file behind.
-        boost::system::error_code ec;
-        boost::filesystem::remove(Slic3r::extended_path(dest_path), ec);
-        return false;
-    }
-    return true;
-#else
-    return mz_zip_reader_extract_to_file(zip, file_index, dest_path.string().c_str(), 0) != 0;
-#endif
-}
-
 std::string decode_archive_entry_path(mz_zip_archive *zip, const mz_zip_archive_file_stat &stat)
 {
    if (stat.m_is_utf8)
@@ -199,13 +156,10 @@ bool extract_archive_confined(const std::string &zip_path_utf8, const std::strin
        }
        const std::string dest_file = dest_dir + "/" + stat.m_filename;
        try {
-            // Use the extended-length form for every filesystem call so entries under a destination
-            // past MAX_PATH are created even with LongPathsEnabled off.
-            const boost::filesystem::path dest_path(dest_file);
-            const boost::filesystem::path io_dest = extended_path(dest_path);
            if (stat.m_is_directory) {
-                if (!boost::filesystem::exists(io_dest))
-                    boost::filesystem::create_directories(io_dest);
+                const boost::filesystem::path dest_path(dest_file);
+                if (!boost::filesystem::exists(dest_path))
+                    boost::filesystem::create_directories(dest_path);
                continue;
            }
            if (stat.m_uncomp_size == 0) {
@@ -213,9 +167,10 @@ bool extract_archive_confined(const std::string &zip_path_utf8, const std::strin
                continue;
            }
            // Replace a symlink at the destination rather than writing through it.
-            if (boost::filesystem::is_symlink(boost::filesystem::symlink_status(io_dest)))
-                boost::filesystem::remove(io_dest);
-            if (!extract_zip_entry_to_file(&archive, stat.m_file_index, dest_path)) {
+            const boost::filesystem::path dest_path(dest_file);
+            if (boost::filesystem::is_symlink(boost::filesystem::symlink_status(dest_path)))
+                boost::filesystem::remove(dest_path);
+            if (!mz_zip_reader_extract_to_file(&archive, stat.m_file_index, dest_file.c_str(), 0)) {
                BOOST_LOG_TRIVIAL(error) << "Unzip: extract file " << stat.m_filename << " to dest " << dest_file << " failed";
                close_zip_reader(&archive);
                return false;
@@ -1,7 +1,6 @@
 #ifndef MINIZ_EXTENSION_HPP
 #define MINIZ_EXTENSION_HPP

-#include <boost/filesystem/path.hpp>
 #include <string>
 #include <miniz.h>

@@ -14,10 +13,6 @@ bool close_zip_writer(mz_zip_archive *zip);
 std::string decode_archive_entry_path(mz_zip_archive *zip, const mz_zip_archive_file_stat &stat);
 // Extracts every entry of the archive under dest_dir. Nothing is written if any entry would resolve outside dest_dir.
 bool extract_archive_confined(const std::string &zip_path_utf8, const std::string &dest_dir);
-// Extracts one entry into dest_path, binary-safe and overwriting. On Windows the destination is
-// opened through an extended-length path so it works past MAX_PATH even with LongPathsEnabled off;
-// a partial file is removed if the write fails. False for a directory/unsupported entry or on error.
-bool extract_zip_entry_to_file(mz_zip_archive *zip, mz_uint file_index, const boost::filesystem::path &dest_path);

 class MZ_Archive {
 public:
@@ -2254,45 +2254,5 @@ bool check_layer_id_pattern(const std::string& pattern, int layer_id){
    return mod >= 0 && mod < count;
 }

-boost::filesystem::path extended_path(const boost::filesystem::path& path) {
-#ifdef WIN32
-    namespace fs = boost::filesystem;
-
-    // Already extended, or an explicit device path (which is not subject to MAX_PATH and must not
-    // be absolutized or normalized): leave it alone.
-    {
-        fs::path prefix_candidate = path;
-        const std::wstring native = prefix_candidate.make_preferred().wstring();
-        if (native.rfind(L"\\\\?\\", 0) == 0 || native.rfind(L"\\\\.\\", 0) == 0)
-            return fs::path(native);
-    }
-
-    fs::path absolute = path;
-    if (!absolute.is_absolute()) {
-        boost::system::error_code ec;
-        absolute = fs::absolute(absolute, ec);
-        if (ec)
-            return path; // can't form a valid prefixed path from a relative one
-    }
-
-    // A trailing separator is redundant to the Win32 APIs, but lexically_normal() would rewrite it
-    // as a "." element, which the "\\?\" prefix (normalisation off) takes literally. Drop it first.
-    while (absolute.has_relative_path() && absolute.filename() == ".")
-        absolute = absolute.parent_path();
-
-    // The "\\?\" prefix turns off Win32 normalisation, so do it here first.
-    absolute = absolute.lexically_normal();
-
-    // Extended paths only recognize backslash separators.
-    const std::wstring native = absolute.make_preferred().wstring();
-    if (native.empty())
-        return path;
-    if (native.rfind(L"\\\\", 0) == 0)
-        return fs::path(L"\\\\?\\UNC\\" + native.substr(2)); // \\server\share\... -> \\?\UNC\server\share\...
-    return fs::path(L"\\\\?\\" + native);                    // C:\dir\... -> \\?\C:\dir\...
-#else
-    return path;
-#endif
-}

 }; // namespace Slic3r
@@ -222,7 +222,6 @@ set(SLIC3R_GUI_SOURCES
    GUI/Gizmos/GLGizmoUtils.hpp
    GUI/GLCanvas3D.cpp
    GUI/GLCanvas3D.hpp
-    GUI/SequentialPrintClearance.hpp
    GUI/GLModel.cpp
    GUI/GLModel.hpp
    GUI/GLSelectionRectangle.cpp
@@ -690,8 +689,6 @@ set(SLIC3R_GUI_SOURCES
    plugin/host/PluginHostUi.hpp
    plugin/host/PluginPages.cpp
    plugin/host/PluginPages.hpp
-    plugin/host/PluginResourceTextures.cpp
-    plugin/host/PluginResourceTextures.hpp
    plugin/CloudPluginService.cpp
    plugin/CloudPluginService.hpp
    plugin/PluginFsUtils.cpp
@@ -715,9 +712,6 @@ set(SLIC3R_GUI_SOURCES
    plugin/pluginTypes/pages/PagesPluginCapability.hpp
    plugin/pluginTypes/pages/PagesPluginCapability.cpp
    plugin/pluginTypes/pages/PagesPluginCapabilityTrampoline.hpp
-    plugin/pluginTypes/resourceTexture/ResourceTexturePluginCapability.hpp
-    plugin/pluginTypes/resourceTexture/ResourceTexturePluginCapability.cpp
-    plugin/pluginTypes/resourceTexture/ResourceTexturePluginCapabilityTrampoline.hpp
    plugin/pluginTypes/script/ScriptPluginCapability.hpp
    plugin/pluginTypes/script/ScriptPluginCapability.cpp
    plugin/pluginTypes/script/ScriptPluginCapabilityTrampoline.hpp
@@ -85,96 +85,6 @@ static std::string float_to_string_with_precision(float value, int precision = 3
    return stream.str();
 }

-static std::string colour_to_ams_string(const wxColour& color)
-{
-    char col_buf[10];
-    sprintf(col_buf, "%02X%02X%02X%02X", (int)color.Red(), (int)color.Green(), (int)color.Blue(), (int)color.Alpha());
-    return col_buf;
-}
-
-static wxColour mix_colour(const wxColour& left, const wxColour& right, double ratio)
-{
-    ratio = std::max(0.0, std::min(1.0, ratio));
-    auto mix_channel = [ratio](unsigned char l, unsigned char r) {
-        return static_cast<unsigned char>(std::round(l + (r - l) * ratio));
-    };
-    return wxColour(mix_channel(left.Red(), right.Red()),
-                    mix_channel(left.Green(), right.Green()),
-                    mix_channel(left.Blue(), right.Blue()),
-                    mix_channel(left.Alpha(), right.Alpha()));
-}
-
-static std::vector<ColorPickerPopup::ColorItem> collect_ams_color_items(DevFilaSystem* fila_system)
-{
-    std::vector<ColorPickerPopup::ColorItem> items;
-    if (!fila_system) return items;
-
-    for (const auto& ams_pair : fila_system->GetAmsList()) {
-        DevAms* ams = ams_pair.second;
-        if (!ams) continue;
-
-        for (const auto& tray_pair : ams->GetTrays()) {
-            DevAmsTray* tray = tray_pair.second;
-            if (!tray || !tray->is_tray_info_ready()) continue;
-
-            ColorPickerPopup::ColorItem item;
-            for (const std::string& col : tray->cols) {
-                item.colors.emplace_back(DevAmsTray::decode_color(col));
-            }
-            if (item.colors.empty() && !tray->color.empty()) {
-                item.colors.emplace_back(DevAmsTray::decode_color(tray->color));
-            }
-            if (item.colors.empty()) continue;
-
-            item.ctype = item.colors.size() > 1 ? tray->ctype : 2;
-            items.emplace_back(std::move(item));
-        }
-    }
-
-    return items;
-}
-
-static std::vector<ColorPickerPopup::ColorItem> collect_preset_color_items(const std::string& filament_id)
-{
-    std::vector<ColorPickerPopup::ColorItem> items;
-    if (filament_id.empty()) return items;
-
-    auto* clr_query = GUI::wxGetApp().get_filament_color_code_query();
-    if (!clr_query) return items;
-
-    auto* agent = wxGetApp().getAgent();
-    const std::string catalog_id = agent ? agent->from_orca_filament_id(filament_id) : filament_id;
-    FilamentColorCodes* color_codes = clr_query->GetFilaInfoMap(wxString::FromUTF8(catalog_id));
-    if (!color_codes || !color_codes->GetFilamentColor2CodeMap()) return items;
-
-    std::set<std::string> seen;
-    for (const auto& color_pair : *color_codes->GetFilamentColor2CodeMap()) {
-        const FilamentColor& fila_color = color_pair.first;
-        FilamentColorCode* color_code = color_pair.second;
-        if (!color_code || fila_color.GetColors().empty()) continue;
-
-        ColorPickerPopup::ColorItem item;
-        item.ctype = fila_color.ColorCount() < 2 ? 2 :
-            (fila_color.m_color_type == FilamentColor::ColorType::GRADIENT_CLR ? 0 : 1);
-        item.name = color_code->GetFilaColorName();
-
-        std::string key = std::to_string(item.ctype);
-        for (const wxColour& color : fila_color.GetColors()) {
-            item.colors.emplace_back(color);
-            char rgba[9];
-            std::snprintf(rgba, sizeof(rgba), "%02X%02X%02X%02X",
-                static_cast<unsigned>(color.Red()), static_cast<unsigned>(color.Green()),
-                static_cast<unsigned>(color.Blue()), static_cast<unsigned>(color.Alpha()));
-            key += "|" + std::string(rgba);
-        }
-
-        if (item.colors.empty() || !seen.insert(key).second) continue;
-        items.emplace_back(std::move(item));
-    }
-
-    return items;
-}
-
 AMSMaterialsSetting::AMSMaterialsSetting(wxWindow *parent, wxWindowID id)
    : DPIDialog(parent, id, _L("AMS Materials Setting"), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxCLOSE_BOX)
    , m_color_picker_popup(ColorPickerPopup(this))
@@ -830,19 +740,8 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
    nozzle_temp_min.ToLong(&nozzle_temp_min_int);
    nozzle_temp_max.ToLong(&nozzle_temp_max_int);
    wxColour color = m_clr_picker->m_colour;
-    std::string tray_color = colour_to_ams_string(color);
-    std::vector<std::string> tray_colors;
-    int tray_ctype = 2;
-    // Only firmware advertising fun2[23] receives the manual multi-color fields.
-    if (obj->is_support_filament_manual_multi_color) {
-        for (const wxColour& selected_color : m_clr_picker->m_cols) {
-            tray_colors.emplace_back(colour_to_ams_string(selected_color));
-        }
-        if (tray_colors.empty()) {
-            tray_colors.emplace_back(tray_color);
-        }
-        tray_ctype = tray_colors.size() > 1 ? m_clr_picker->ctype : 2;
-    }
+    char col_buf[10];
+    sprintf(col_buf, "%02X%02X%02X%02X", (int)color.Red(), (int)color.Green(), (int)color.Blue(), (int)color.Alpha());

    if (ams_filament_id.empty() || nozzle_temp_min.empty() || nozzle_temp_max.empty() || m_filament_type.empty()) {
        BOOST_LOG_TRIVIAL(trace) << "Invalid Setting id";
@@ -861,33 +760,13 @@ void AMSMaterialsSetting::on_select_ok(wxCommandEvent &event)
                            << ", tray_info_idx (filament_id) = " << ams_filament_id
                            << ", setting_id = " << ams_setting_id
                            << ", tray_type = " << m_filament_type
-                            << ", tray_color = " << tray_color
+                            << ", tray_color = " << col_buf
                            << ", nozzle_temp_min = " << nozzle_temp_min_int
                            << ", nozzle_temp_max = " << nozzle_temp_max_int;

    // set filament
    if (m_is_third) {
-        obj->command_ams_filament_settings(ams_id, slot_id, ams_filament_id, ams_setting_id, tray_color, m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int,
-                                           tray_colors, tray_ctype);
-
-        // Refresh the edited tray immediately while its MQTT acknowledgement is pending.
-        DevAmsTray* tray = nullptr;
-        if (is_virtual_tray()) {
-            for (auto& virtual_tray : obj->vt_slot) {
-                if (virtual_tray.id == std::to_string(ams_id)) {
-                    tray = &virtual_tray;
-                    break;
-                }
-            }
-        } else {
-            tray = obj->GetFilaSystem()->GetAmsTray(std::to_string(ams_id), std::to_string(slot_id));
-        }
-        if (tray) {
-            tray->color = tray_color;
-            tray->cols = tray_colors;
-            tray->ctype = tray_ctype;
-            tray->set_hold_count();
-        }
+        obj->command_ams_filament_settings(ams_id, slot_id, ams_filament_id, ams_setting_id, std::string(col_buf), m_filament_type, nozzle_temp_min_int, nozzle_temp_max_int);
    }

    //reset param
@@ -1044,15 +923,8 @@ void AMSMaterialsSetting::set_ctype(int ctype)

 void AMSMaterialsSetting::on_picker_color(wxCommandEvent& event)
 {
-    std::vector<wxColour> colors = m_color_picker_popup.get_selected_colours();
-    if (colors.empty()) {
-        unsigned int color_num = event.GetInt();
-        colors.emplace_back(color_num >> 24 & 0xFF, color_num >> 16 & 0xFF, color_num >> 8 & 0xFF, color_num & 0xFF);
-    }
-
-    set_ctype(m_color_picker_popup.get_selected_ctype());
-    set_color(colors.front());
-    set_colors(colors);
+    unsigned int color_num  = event.GetInt();
+    set_color(wxColour(color_num>>24&0xFF, color_num>>16&0xFF, color_num>>8&0xFF, color_num&0xFF));
 }

 void AMSMaterialsSetting::on_clr_picker(wxMouseEvent &event)
@@ -1067,12 +939,14 @@ void AMSMaterialsSetting::on_clr_picker(wxMouseEvent &event)
        }
    }

-    m_color_picker_popup.set_ams_colours(collect_ams_color_items(obj->GetFilaSystem().get()));
-    m_color_picker_popup.set_preset_colours(collect_preset_color_items(ams_filament_id));
-    m_color_picker_popup.set_def_colour(m_clr_picker->m_colour, m_clr_picker->m_cols, m_clr_picker->ctype);
+    std::vector<wxColour> ams_colors;
+    obj->GetFilaSystem()->CollectAmsColors(ams_colors);
+
    wxPoint img_pos = m_clr_picker->ClientToScreen(wxPoint(0, 0));
    wxPoint popup_pos(img_pos.x - m_color_picker_popup.GetSize().x - FromDIP(95), img_pos.y - FromDIP(65));
    m_color_picker_popup.Position(popup_pos, wxSize(0, 0));
+    m_color_picker_popup.set_ams_colours(ams_colors);
+    m_color_picker_popup.set_def_colour(m_clr_picker->m_colour);
    m_color_picker_popup.Popup();
 }

@@ -1861,46 +1735,7 @@ void ColorPicker::doRender(wxDC& dc)
    auto radius = m_show_full ? size.x / 2 - FromDIP(1) : size.x / 2;
    if (m_selected) radius -= FromDIP(1);

-    if (m_show_full && m_cols.size() > 1) {
-        if (ctype == 0) {
-            const double center_x = size.x / 2.0;
-            const double center_y = size.y / 2.0;
-            const double draw_radius = radius;
-            dc.SetPen(*wxTRANSPARENT_PEN);
-            for (int x = 0; x < size.x; ++x) {
-                const double dx = x + 0.5 - center_x;
-                if (std::abs(dx) > draw_radius) continue;
-
-                const double half_height = std::sqrt(std::max(0.0, draw_radius * draw_radius - dx * dx));
-                const int top = std::max(0, static_cast<int>(std::ceil(center_y - half_height)));
-                const int bottom = std::min(size.y - 1, static_cast<int>(std::floor(center_y + half_height)));
-                const double pos = size.x > 1 ? static_cast<double>(x) / (size.x - 1) : 0.0;
-                const double scaled = pos * (m_cols.size() - 1);
-                const size_t idx = std::min(static_cast<size_t>(scaled), m_cols.size() - 2);
-                const double ratio = scaled - idx;
-
-                if (top <= bottom) {
-                    dc.SetBrush(wxBrush(mix_colour(m_cols[idx], m_cols[idx + 1], ratio)));
-                    dc.DrawRectangle(x, top, 1, bottom - top + 1);
-                }
-            }
-        }
-        else {
-            float ev_angle = 360.0 / m_cols.size();
-            const float overlap = 2.0f;
-            wxPoint center(size.x / 2, size.y / 2);
-            dc.SetPen(*wxTRANSPARENT_PEN);
-            dc.SetBrush(wxBrush(m_cols.front()));
-            dc.DrawCircle(center.x, center.y, radius);
-            for (int i = 0; i < m_cols.size(); i++) {
-                dc.SetBrush(m_cols[i]);
-                float startAngle = 270.0f + i * ev_angle;
-                float endAngle = startAngle + ev_angle;
-                dc.DrawEllipticArc(center.x - radius, center.y - radius, 2 * radius, 2 * radius, startAngle - overlap, endAngle + overlap);
-            }
-        }
-    }
-    else if (alpha == 0) {
+    if (alpha == 0) {
        wxSize bmp_size = m_bitmap_transparent_def.GetBmpSize();
        int center_x = (size.x - bmp_size.x) / 2;
        int center_y = (size.y - bmp_size.y) / 2;
@@ -1942,6 +1777,52 @@ void ColorPicker::doRender(wxDC& dc)
        dc.SetPen(wxPen(wxColour("#6B6B6B")));
        dc.SetBrush(*wxTRANSPARENT_BRUSH);
        dc.DrawCircle(size.x / 2, size.y / 2, radius);
+
+        if (m_cols.size() > 1) {
+            if (ctype == 0) {
+                int left = FromDIP(0);
+                float total_width = size.x;
+                int gwidth = std::round(total_width / (m_cols.size() - 1));
+
+                for (int i = 0; i < m_cols.size() - 1; i++) {
+
+                    if ((left + gwidth) > (size.x)) {
+                        gwidth = size.x - left;
+                    }
+
+                    auto rect = wxRect(left, 0, gwidth, size.y);
+                    dc.GradientFillLinear(rect, m_cols[i], m_cols[i + 1], wxEAST);
+                    left += gwidth;
+                }
+                if (wxGetApp().dark_mode()) {
+                    dc.DrawBitmap(m_bitmap_border_dark, wxPoint(0, 0));
+                }
+                else {
+                    dc.DrawBitmap(m_bitmap_border, wxPoint(0, 0));
+                }
+            }
+            else {
+                float ev_angle = 360.0 / m_cols.size();
+                float startAngle = 270.0;
+                float endAngle = 270.0;
+                dc.SetPen(*wxTRANSPARENT_PEN);
+                for (int i = 0; i < m_cols.size(); i++) {
+                    dc.SetBrush(m_cols[i]);
+                    endAngle += ev_angle;
+                    endAngle = endAngle > 360.0 ? endAngle - 360.0 : endAngle;
+                    wxPoint center(size.x / 2, size.y / 2);
+                    dc.DrawEllipticArc(center.x - radius, center.y - radius, 2 * radius, 2 * radius, startAngle, endAngle);
+                    startAngle += ev_angle;
+                    startAngle = startAngle > 360.0 ? startAngle - 360.0 : startAngle;
+                }
+                if (wxGetApp().dark_mode()) {
+                    dc.DrawBitmap(m_bitmap_border_dark, wxPoint(0, 0));
+                }
+                else {
+                    dc.DrawBitmap(m_bitmap_border, wxPoint(0, 0));
+                }
+            }
+        }
    }

    if (m_is_empty) {
@@ -2010,21 +1891,19 @@ ColorPickerPopup::ColorPickerPopup(wxWindow* parent)
    m_ams_fg_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);

    //other
-    m_other_fg_sizer = new wxFlexGridSizer(0, 8, 0, 0);
-    m_other_fg_sizer->SetFlexibleDirection(wxBOTH);
-    m_other_fg_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
+    wxFlexGridSizer* fg_sizer;
+    fg_sizer = new wxFlexGridSizer(0, 8, 0, 0);
+    fg_sizer->SetFlexibleDirection(wxBOTH);
+    fg_sizer->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);


    for (wxColour col : m_def_colors) {
        auto cp = new ColorPicker(m_def_color_box, wxID_ANY, wxDefaultPosition, wxDefaultSize);
        cp->set_color(col);
-        cp->set_colors({col});
-        cp->ctype = 2;
        cp->set_selected(false);
        cp->SetBackgroundColour(StateColor::darkModeColorFor(wxColour(238,238,238)));
        m_color_pickers.push_back(cp);
-        m_default_color_pickers.push_back(cp);
-        m_other_fg_sizer->Add(cp, 0, wxALL, FromDIP(3));
+        fg_sizer->Add(cp, 0, wxALL, FromDIP(3));
        cp->Bind(wxEVT_LEFT_DOWN, [this, cp](auto& e) {
            set_def_colour(cp->m_colour);

@@ -2091,7 +1970,7 @@ ColorPickerPopup::ColorPickerPopup(wxWindow* parent)
    m_sizer_box->Add(m_sizer_ams, 1, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
    m_sizer_box->Add(m_ams_fg_sizer, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
    m_sizer_box->Add(m_sizer_other, 1, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
-    m_sizer_box->Add(m_other_fg_sizer, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
+    m_sizer_box->Add(fg_sizer, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
    m_sizer_box->Add(m_sizer_custom, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(10));
    m_sizer_box->Add(m_custom_cp, 0, wxEXPAND|wxLEFT|wxRIGHT, FromDIP(16));
    m_sizer_box->Add(0, 0, 0, wxTOP, FromDIP(10));
@@ -2102,7 +1981,7 @@ ColorPickerPopup::ColorPickerPopup(wxWindow* parent)
    m_def_color_box->Fit();

    m_sizer_main->Add(m_def_color_box, 0, wxALL | wxEXPAND, 10);
-    SetSizerAndFit(m_sizer_main);
+    SetSizer(m_sizer_main);
    Layout();
    Fit();

@@ -2140,15 +2019,13 @@ void ColorPickerPopup::on_custom_clr_picker(wxMouseEvent& /*event*/)
    wxPostEvent(GetParent(), evt);
 }

-void ColorPickerPopup::set_ams_colours(const std::vector<ColorItem>& ams)
+void ColorPickerPopup::set_ams_colours(std::vector<wxColour> ams)
 {
-    m_ams_fg_sizer->Clear(false);
    if (m_ams_color_pickers.size() > 0) {
        for (ColorPicker* col_pick:m_ams_color_pickers) {

            std::vector<ColorPicker*>::iterator iter = find(m_color_pickers.begin(), m_color_pickers.end(), col_pick);
            if (iter != m_color_pickers.end()) {
-                col_pick->Hide();
                col_pick->Destroy();
                m_color_pickers.erase(iter);
            }
@@ -2158,22 +2035,17 @@ void ColorPickerPopup::set_ams_colours(const std::vector<ColorItem>& ams)
    }


-    m_ams_color_items = ams;
-    for (const ColorItem& item : m_ams_color_items) {
-        if (item.colors.empty()) continue;
-
+    m_ams_colors = ams;
+    for (wxColour col : m_ams_colors) {
        auto cp = new ColorPicker(m_def_color_box, wxID_ANY, wxDefaultPosition, wxDefaultSize);
-        cp->set_color(item.colors.front());
-        cp->set_colors(item.colors);
-        cp->ctype = item.colors.size() > 1 ? item.ctype : 2;
-        cp->set_show_full(true);
+        cp->set_color(col);
        cp->set_selected(false);
        cp->SetBackgroundColour(StateColor::darkModeColorFor(wxColour(238,238,238)));
        m_color_pickers.push_back(cp);
        m_ams_color_pickers.push_back(cp);
        m_ams_fg_sizer->Add(cp, 0, wxALL, FromDIP(3));
        cp->Bind(wxEVT_LEFT_DOWN, [this, cp](auto& e) {
-            set_def_colour(cp->m_colour, cp->m_cols, cp->ctype);
+            set_def_colour(cp->m_colour);

            wxCommandEvent evt(EVT_SELECTED_COLOR);
            unsigned long g_col = ((cp->m_colour.Red() & 0xff) << 24) + ((cp->m_colour.Green() & 0xff) << 16) + ((cp->m_colour.Blue() & 0xff) << 8) + (cp->m_colour.Alpha() & 0xff);
@@ -2186,68 +2058,9 @@ void ColorPickerPopup::set_ams_colours(const std::vector<ColorItem>& ams)
    Fit();
 }

-void ColorPickerPopup::set_preset_colours(const std::vector<ColorItem>& preset_colors)
-{
-    m_other_fg_sizer->Clear(false);
-    if (!m_preset_color_pickers.empty()) {
-        for (ColorPicker* col_pick : m_preset_color_pickers) {
-            auto iter = std::find(m_color_pickers.begin(), m_color_pickers.end(), col_pick);
-            if (iter != m_color_pickers.end()) {
-                col_pick->Hide();
-                col_pick->Destroy();
-                m_color_pickers.erase(iter);
-            }
-        }
-        m_preset_color_pickers.clear();
-    }
-
-    for (const ColorItem& item : preset_colors) {
-        if (item.colors.empty()) continue;
-
-        auto cp = new ColorPicker(m_def_color_box, wxID_ANY, wxDefaultPosition, wxDefaultSize);
-        cp->set_color(item.colors.front());
-        cp->set_colors(item.colors);
-        cp->ctype = item.colors.size() > 1 ? item.ctype : 2;
-        cp->set_show_full(true);
-        cp->set_selected(false);
-        cp->SetBackgroundColour(StateColor::darkModeColorFor(wxColour(238,238,238)));
-        if (!item.name.empty()) {
-            cp->SetToolTip(item.name);
-        }
-
-        m_color_pickers.push_back(cp);
-        m_preset_color_pickers.push_back(cp);
-        cp->Bind(wxEVT_LEFT_DOWN, [this, cp](auto& e) {
-            set_def_colour(cp->m_colour, cp->m_cols, cp->ctype);
-
-            wxCommandEvent evt(EVT_SELECTED_COLOR);
-            unsigned long g_col = ((cp->m_colour.Red() & 0xff) << 24) + ((cp->m_colour.Green() & 0xff) << 16) + ((cp->m_colour.Blue() & 0xff) << 8) + (cp->m_colour.Alpha() & 0xff);
-            evt.SetInt(g_col);
-            wxPostEvent(GetParent(), evt);
-        });
-    }
-
-    const bool show_default_colours = m_preset_color_pickers.empty();
-    for (ColorPicker* cp : m_default_color_pickers) {
-        cp->Show(show_default_colours);
-    }
-    for (ColorPicker* cp : (show_default_colours ? m_default_color_pickers : m_preset_color_pickers)) {
-        m_other_fg_sizer->Add(cp, 0, wxALL, FromDIP(3));
-    }
-
-    m_other_fg_sizer->Layout();
-    Layout();
-    Fit();
-}
-
-void ColorPickerPopup::set_def_colour(wxColour col, std::vector<wxColour> cols, int ctype)
+void ColorPickerPopup::set_def_colour(wxColour col)
 {
    m_def_col = col;
-    if (cols.empty()) {
-        cols.push_back(col);
-    }
-    m_def_cols = cols;
-    m_def_ctype = m_def_cols.size() > 1 ? ctype : 2;

    for (ColorPicker* cp : m_color_pickers) {
        if (cp->m_selected) {
@@ -2256,8 +2069,7 @@ void ColorPickerPopup::set_def_colour(wxColour col, std::vector<wxColour> cols,
    }

    for (ColorPicker* cp : m_color_pickers) {
-        if (!cp->IsShown()) continue;
-        if (cp->ctype == m_def_ctype && cp->m_cols == m_def_cols) {
+        if (cp->m_colour == m_def_col) {
            cp->set_selected(true);
            break;
        }
@@ -82,22 +82,14 @@ public:
 class ColorPickerPopup : public PopupWindow
 {
 public:
-    struct ColorItem
-    {
-        std::vector<wxColour> colors;
-        int                   ctype = 2;
-        wxString              name;
-    };
-
    ScalableBitmap m_ts_bitmap_custom;
    wxStaticBitmap* m_ts_stbitmap_custom;
    StaticBox* m_custom_cp;
    StaticBox* m_def_color_box;
    wxFlexGridSizer* m_ams_fg_sizer;
-    wxFlexGridSizer* m_other_fg_sizer;
    wxColour m_def_col;
    std::vector<wxColour> m_def_colors;
-    std::vector<ColorItem> m_ams_color_items;
+    std::vector<wxColour> m_ams_colors;
    std::vector<ColorPicker*> m_color_pickers;
    std::vector<ColorPicker*> m_ams_color_pickers;

@@ -105,20 +97,13 @@ public:
    ColorPickerPopup(wxWindow* parent);
    ~ColorPickerPopup() {};
    void on_custom_clr_picker(wxMouseEvent& event);
-    void set_ams_colours(const std::vector<ColorItem>& ams);
-    void set_preset_colours(const std::vector<ColorItem>& preset_colors);
-    void set_def_colour(wxColour col, std::vector<wxColour> cols = {}, int ctype = 2);
-    const std::vector<wxColour>& get_selected_colours() const { return m_def_cols; }
-    int get_selected_ctype() const { return m_def_ctype; }
+    void set_ams_colours(std::vector<wxColour> ams);
+    void set_def_colour(wxColour col);
    void paintEvent(wxPaintEvent& evt);
    virtual void OnDismiss() wxOVERRIDE;
    virtual bool ProcessLeftDown(wxMouseEvent& event) wxOVERRIDE;

-private:
-    std::vector<ColorPicker*> m_default_color_pickers;
-    std::vector<ColorPicker*> m_preset_color_pickers;
-    std::vector<wxColour> m_def_cols;
-    int m_def_ctype = 2;
+public:
 };


@@ -747,9 +747,7 @@ Print::ApplyStatus BackgroundSlicingProcess::apply(const Model& model, const Dyn

    // Orca: prevent resetting under gcode viewer mode
    if (invalidated != PrintBase::APPLY_STATUS_UNCHANGED) {
-        // Use the app’s plater accessor instead of going through mainframe, otherwise anything during startup that reaches apply() 
-        // (loading presets, config or input files, e.g. from the CLI) therefore dereferences a null `mainframe` and crashes.
-        const auto plater = GUI::wxGetApp().plater();
+        const auto plater = GUI::wxGetApp().mainframe->m_plater;
        if (plater && plater->only_gcode_mode()) {
            invalidated = PrintBase::APPLY_STATUS_UNCHANGED;
        }
@@ -163,8 +163,8 @@ public:
    ~devPrinterUtil() = delete;

 public:
-    static bool IsVirtualSlot(int ams_id) { return (ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID);}
-    static bool IsVirtualSlot(const std::string& ams_id) { return (ams_id == VIRTUAL_AMS_MAIN_ID_STR || ams_id == VIRTUAL_AMS_DEPUTY_ID_STR); }
+    static bool IsVirtualSlot(int ams_id);
+    static bool IsVirtualSlot(const std::string& ams_id);
 };

 namespace GUI
@@ -198,3 +198,6 @@ template<> struct std::hash<NozzleDef>
        return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
    };
 };
+
+// key(extruder_id) -> { key1(nozzle type info), val1( number of the nozzle type)}
+using ExtruderNozzleInfos = std::unordered_map<int, std::unordered_map<NozzleDef, int>>;
@@ -8,6 +8,7 @@
 #include <cstdlib>
 #include <chrono>
 #include <nlohmann/json.hpp>
+#include <wx/app.h>
 #include <wx/colour.h>
 #include <string>
 #include <wx/string.h>
@@ -33,6 +34,36 @@
 using namespace nlohmann;

 namespace Slic3r {
+
+bool devPrinterUtil::IsVirtualSlot(int ams_id)
+{
+    // When the app or preset bundle is unavailable we cannot know the vendor's
+    // extruder count, so fall back deterministically to the fixed Bambu pair
+    // {255, 254} rather than guessing from an unknown generic layout.
+    if (wxTheApp == nullptr || GUI::wxGetApp().preset_bundle == nullptr || GUI::wxGetApp().preset_bundle->is_bbl_vendor())
+        return ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID;
+
+    const int extruder_count = GUI::wxGetApp().preset_bundle->get_printer_extruder_count();
+    return ams_id >= VIRTUAL_TRAY_MAIN_ID - extruder_count + 1 && ams_id <= VIRTUAL_TRAY_MAIN_ID;
+}
+
+bool devPrinterUtil::IsVirtualSlot(const std::string& ams_id)
+{
+    // Strict: only a fully numeric string is a valid slot id. std::stoi alone
+    // would accept trailing garbage (e.g. "255abc" -> 255).
+    if (ams_id.empty())
+        return false;
+    for (char c : ams_id) {
+        if (c < '0' || c > '9')
+            return false;
+    }
+    try {
+        return IsVirtualSlot(std::stoi(ams_id));
+    } catch (...) {
+        return false;
+    }
+}
+
 static int _hex_digit_to_int(const char c) { return (c >= '0' && c <= '9') ? c - '0' : (c >= 'A' && c <= 'F') ? c - 'A' + 10 : (c >= 'a' && c <= 'f') ? c - 'a' + 10 : -1; }

 wxColour DevAmsTray::decode_color(const std::string &color)
@@ -200,18 +231,22 @@ wxString DevAms::GetDisplayName() const

 int DevAms::GetSlotCount() const
 {
-    // GetAmsType() maps AMS_LITE_MIXED -> AMS_LITE, so N9 reports 4 slots like AMS-Lite.
-    auto ams_type = GetAmsType();
-    if (ams_type == AMS || ams_type == AMS_LITE || ams_type == N3F)
-    {
-        return 4;
-    }
-    else if (ams_type == N3S)
-    {
+    // N3S is a 1-slot Bambu contract, so report 1 regardless of whether the
+    // preset bundle is momentarily unavailable (m_trays.size() can be 0).
+    if (GetAmsType() == N3S)
        return 1;
+
+    if (wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr &&
+        GUI::wxGetApp().preset_bundle->is_bbl_vendor()) {
+        // GetAmsType() maps AMS_LITE_MIXED -> AMS_LITE, so N9 reports 4 slots like AMS-Lite.
+        auto ams_type = GetAmsType();
+        if (ams_type == AMS || ams_type == AMS_LITE || ams_type == N3F)
+        {
+            return 4;
+        }
    }

-    return 1;
+    return static_cast<int>(m_trays.size());
 }

 DevAmsTray* DevAms::GetTray(const std::string& tray_id) const
@@ -302,13 +337,21 @@ int DevFilaSystem::GetExtruderIdByAmsId(const std::string& ams_id) const
    {
        return it->second->GetExtruderId();
    }
-    else if (stoi(ams_id) == VIRTUAL_TRAY_MAIN_ID)
-    {
-        return MAIN_EXTRUDER_ID;
+
+    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
+    if (!is_bbl_vendor && GetOwner()) {
+        for (const auto& tray : GetOwner()->vt_slot) {
+            if (tray.id == ams_id)
+                return VIRTUAL_TRAY_MAIN_ID - std::stoi(ams_id);
+        }
    }
-    else if (stoi(ams_id) == VIRTUAL_TRAY_DEPUTY_ID)
-    {
+
+    if (is_bbl_vendor && ams_id == VIRTUAL_AMS_MAIN_ID_STR)
+        return MAIN_EXTRUDER_ID;
+    if (is_bbl_vendor && ams_id == VIRTUAL_AMS_DEPUTY_ID_STR)
        return DEPUTY_EXTRUDER_ID;
+    if (!is_bbl_vendor && devPrinterUtil::IsVirtualSlot(ams_id)) {
+        return VIRTUAL_TRAY_MAIN_ID - std::stoi(ams_id);
    }

    assert(false && __FUNCTION__);
@@ -325,9 +368,22 @@ std::string DevFilaSystem::GetNozzleFlowStringByAmsId(const std::string& ams_id)
 std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
 {
    std::map<int, DevAmsSlotId> tray_id_map;
-    tray_id_map[VIRTUAL_TRAY_MAIN_ID]   = DevAmsSlotId{VIRTUAL_TRAY_MAIN_ID, 0};
-    tray_id_map[VIRTUAL_TRAY_DEPUTY_ID] = DevAmsSlotId{VIRTUAL_TRAY_DEPUTY_ID, 0};
+    const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr && GUI::wxGetApp().preset_bundle->is_bbl_vendor();
+    if (is_bbl_vendor) {
+        tray_id_map[VIRTUAL_TRAY_MAIN_ID]   = DevAmsSlotId{VIRTUAL_TRAY_MAIN_ID, 0};
+        tray_id_map[VIRTUAL_TRAY_DEPUTY_ID] = DevAmsSlotId{VIRTUAL_TRAY_DEPUTY_ID, 0};
+    } else if (GetOwner()) {
+        for (const auto& tray : GetOwner()->vt_slot) {
+            try {
+                const int tray_id = std::stoi(tray.id);
+                tray_id_map[tray_id] = DevAmsSlotId{tray_id, 0};
+            } catch (...) {
+                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << " invalid virtual tray id: " << tray.id;
+            }
+        }
+    }

+    int generic_tray_index = 0;
    for (auto& [ams_id, ams_item] : GetAmsList()) {
        for (auto &[slot_id, slot_item] : ams_item->GetTrays()) {
            if (ams_item && slot_item) {
@@ -335,9 +391,11 @@ std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
                    int ams_id_int  = stoi(ams_id);
                    int slot_id_int = stoi(slot_id);
                    int tray_index  = -1;
-                    if (ams_item->GetAmsType() == DevAms::N3S) {
+                    if (!is_bbl_vendor) {
+                        tray_index = generic_tray_index + slot_id_int;
+                    } else if (ams_item->GetAmsType() == DevAms::N3S) {
                        tray_index = ams_id_int;
-                    } else if(ams_item->GetAmsType() == DevAms::AMS_LITE && ams_item->IsAmsLiteMixed()) {
+                    } else if (ams_item->GetAmsType() == DevAms::AMS_LITE && ams_item->IsAmsLiteMixed()) {
                        tray_index = 24 + slot_id_int;
                    } else {
                        tray_index = (ams_id_int * 4 + slot_id_int);
@@ -348,6 +406,8 @@ std::map<int, DevAmsSlotId> DevFilaSystem::GetTrayIndexMap()
                }
            }
        }
+        if (!is_bbl_vendor)
+            generic_tray_index += static_cast<int>(ams_item->GetTrays().size());
    }

    return  tray_id_map;
@@ -456,6 +516,13 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                    ams_id_set.insert(it->first);
                }

+                // Bambu trays index their exist bit as ams_id*4+tray_id; a generic (non-Bambu) unit
+                // reports its own lane count, so its trays carry a cumulative lane index instead.
+                // Same index DevFilaSystem::GetTrayIndexMap() builds and the agent sets bits with.
+                const bool is_bbl_vendor = wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr &&
+                                           GUI::wxGetApp().preset_bundle->is_bbl_vendor();
+                int generic_tray_base = 0;
+
                for (auto it = j_ams.begin(); it != j_ams.end(); it++)
                {
                    if (!it->contains("id")) continue;
@@ -795,7 +862,18 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS

                                    if (type_id < 4)
                                    {
-                                        curr_tray->is_exists = (obj->tray_exist_bits & (1 << (ams_id_int * 4 + tray_id_int))) != 0 ? true : false;
+                                        if (is_bbl_vendor)
+                                        {
+                                            curr_tray->is_exists = (obj->tray_exist_bits & (1 << (ams_id_int * 4 + tray_id_int))) != 0 ? true : false;
+                                        }
+                                        else
+                                        {
+                                            // A generic unit is not four slots wide, so its trays carry a
+                                            // cumulative lane index across units instead of ams_id*4+tray_id.
+                                            const int tray_bit = generic_tray_base + tray_id_int;
+                                            curr_tray->is_exists = tray_bit >= 0 && tray_bit < 32 &&
+                                                                   (obj->tray_exist_bits & (1UL << tray_bit)) != 0;
+                                        }
                                    }
                                    else if (type_id == DevAms::AMS_LITE_MIXED)
                                    {
@@ -851,6 +929,9 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
                            }
                        }
                    }
+                    if (!is_bbl_vendor && it->contains("tray") && (*it)["tray"].is_array()) {
+                        generic_tray_base += static_cast<int>((*it)["tray"].size());
+                    }
                }
                // remove not in amsList
                for (auto it = ams_id_set.begin(); it != ams_id_set.end(); it++)
@@ -866,6 +947,21 @@ void DevFilaSystemParser::ParseV1_0(const json& jj, MachineObject* obj, DevFilaS
            }
        }
    }
+
+    // Give every live device extruder an external virtual tray slot (non-Bambu) so a plugin agent
+    // that reaches the model only through this parser also gets the shared external-slot topology.
+    if (obj)
+        obj->ensure_external_virtual_tray_slots();
+
+    // Diagnostic: summarize the AMS state this production parse produced, so the agent boundary
+    // (submit_ams_payload) box/tray counts can be correlated with what actually landed in the model.
+    if (obj && system) {
+        size_t parsed_trays = 0;
+        for (const auto& kv : system->amsList)
+            parsed_trays += kv.second->GetTrays().size();
+        BOOST_LOG_TRIVIAL(info) << "DevFilaSystemParser::ParseV1_0: parsed units " << system->amsList.size()
+                                << " trays " << parsed_trays;
+    }
 }

 static DevAms::AmsType ams_type_from_string(const std::string& s)
@@ -876,6 +972,23 @@ static DevAms::AmsType ams_type_from_string(const std::string& s)
    return DevAms::AMS; // default
 }

+void grow_virtual_tray_slots(std::vector<DevAmsTray>& slots, std::size_t tray_id)
+{
+    // Address a slot by its virtual tray id, never by a raw vector index: the slot for `tray_id`
+    // lives at index VIRTUAL_TRAY_MAIN_ID - tray_id and placeholder entries carry
+    // id = VIRTUAL_TRAY_MAIN_ID - index. Append-only, so a slot that already holds reported
+    // metadata keeps it and a sparse/out-of-order report cannot shift the id <-> extruder mapping.
+    if (tray_id > static_cast<std::size_t>(VIRTUAL_TRAY_MAIN_ID))
+        return;
+    const std::size_t slot_index = static_cast<std::size_t>(VIRTUAL_TRAY_MAIN_ID) - tray_id;
+    while (slots.size() <= slot_index) {
+        slots.emplace_back(std::to_string(VIRTUAL_TRAY_MAIN_ID - static_cast<int>(slots.size())));
+        // A filler only makes the slot addressable; it is topology, not a reported spool. Callers
+        // overwrite the target entry with reported metadata, which clears this marker.
+        slots.back().is_slot_placeholder = true;
+    }
+}
+
 void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* obj, DevFilaSystem* system)
 {
    if (!system || !data.is_object())
@@ -913,6 +1026,8 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
            }

            ams->m_exist               = true;
+            ams->m_binded_extruder_set = {ext_id};
+            ams->m_binded_switcher_pos.reset();
            ams->m_current_temperature = u.value("temperature", (float) INVALID_AMS_TEMPERATURE);
            ams->m_humidity_percent    = u.value("humidity_percent", -1);
            ams->m_left_dry_time       = u.value("dry_time_min", 0);
@@ -995,16 +1110,21 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
    }

    // --- external / direct spools -> obj->vt_slot ---
-    // extruder 0 -> main virtual slot, extruder >0 -> deputy.
+    // Keep one virtual slot per extruder. The legacy two-extruder mapping uses
+    // 255 for extruder 0 and 254 for extruder 1; continue that sequence for
+    // additional extruders (253, 252, ...).
    if (obj && data.contains("external") && data["external"].is_array())
    {
-        obj->vt_slot.clear();
+        std::map<int, DevAmsTray> external_slots;
        for (const auto& e : data["external"])
        {
            if (!e.is_object())
                continue;
            const int  ext   = e.value("extruder", MAIN_EXTRUDER_ID);
-            const int  vt_id = (ext == MAIN_EXTRUDER_ID) ? VIRTUAL_TRAY_MAIN_ID : VIRTUAL_TRAY_DEPUTY_ID;
+            if (ext < MAIN_EXTRUDER_ID || ext >= VIRTUAL_TRAY_MAIN_ID)
+                continue;
+
+            const int  vt_id = VIRTUAL_TRAY_MAIN_ID - ext;
            DevAmsTray tray(std::to_string(vt_id));
            tray.is_exists       = e.value("loaded", false);
            tray.m_fila_type     = e.value("material", std::string());
@@ -1013,9 +1133,26 @@ void DevFilaSystemParser::ParseAgentFilament(const json& data, MachineObject* ob
            tray.nozzle_temp_min = std::to_string(e.value("nozzle_temp_min", 0));
            tray.nozzle_temp_max = std::to_string(e.value("nozzle_temp_max", 0));
            tray.remain          = e.value("remain_percent", -1);
-            obj->vt_slot.push_back(tray);
+            external_slots.insert_or_assign(ext, std::move(tray));
+        }
+
+        // Place each reported spool at its own index (VIRTUAL_TRAY_MAIN_ID - extruder_id) instead of
+        // appending in report order: a sparse or out-of-order report must not compact the vector and
+        // shift the slot -> extruder association.
+        obj->vt_slot.clear();
+        for (const auto& entry : external_slots)
+        {
+            // entry.first is the extruder id; its virtual tray id is VIRTUAL_TRAY_MAIN_ID - extruder_id
+            // and the slot lives at vector index extruder_id (the id <-> index mapping grow applies).
+            grow_virtual_tray_slots(obj->vt_slot, static_cast<std::size_t>(VIRTUAL_TRAY_MAIN_ID - entry.first));
+            obj->vt_slot[entry.first] = entry.second;
        }
    }
+
+    // Fill any extruder still missing a slot so the model always has one external slot per live
+    // extruder, even when the agent reported no external data at all. Preserves reported metadata.
+    if (obj)
+        obj->ensure_external_virtual_tray_slots();
 }

 }
@@ -7,6 +7,7 @@
 #include "DevFilaSwitch.h"
 #include "DevUtil.h"

+#include <cstddef>
 #include <map>
 #include <set>
 #include <string>
@@ -82,7 +83,7 @@ public:
    wxColour        wx_color;
    bool            is_bbl;
    bool            is_exists = false;
-    bool            is_slot_placeholder = false;  // Orca: True for empty tray slots from pull-mode agents
+    bool            is_slot_placeholder = false;  // Orca: True for synthetic topology slots or empty reported trays
    int             hold_count = 0;
    int             remain = 0;         // filament remain: 0 ~ 100

@@ -114,6 +115,16 @@ public:
    std::optional<DevFilamentDryingPreset> get_ams_drying_preset() const;
 };

+/**
+ * Ensure the virtual-tray vector can address the slot for a virtual tray id. The slot's index is
+ * `VIRTUAL_TRAY_MAIN_ID - tray_id` and placeholder entries carry id = VIRTUAL_TRAY_MAIN_ID - index.
+ * Existing entries are left untouched, so a slot already populated with reported filament data
+ * keeps it; callers then assign the reported tray at index `VIRTUAL_TRAY_MAIN_ID - tray_id`.
+ * Appended placeholders are marked `is_slot_placeholder`, so consumers can tell a synthetic
+ * topology filler from a spool the printer actually reported (overwriting the entry clears it).
+ */
+void grow_virtual_tray_slots(std::vector<DevAmsTray>& slots, std::size_t tray_id);
+
 /**
 * DevAms - Represents a single AMS (Automatic Material System) unit.
 *
@@ -348,7 +359,7 @@ public:
    DevAmsTray* GetAmsTray(const std::string& ams_id, const std::string& tray_id) const;
    void        CollectAmsColors(std::vector<wxColour>& ams_colors) const;

-    // Map a linear tray index -> {ams_id, slot_id}. Includes the two virtual (external-spool) trays,
+    // Map a linear tray index -> {ams_id, slot_id}. Includes virtual external-spool trays,
    // N3S single-slot units, and the A2L/N9 AMS-Lite-mixed layout (trays 24-27).
    std::map<int, DevAmsSlotId> GetTrayIndexMap();

@@ -433,4 +444,4 @@ struct DevFilamentDryingPreset
    float filament_dev_ams_drying_heat_distortion_temperature = 0.0f;
 };

-}// namespace Slic3r
+}// namespace Slic3r
@@ -9,6 +9,7 @@
 #include <vector>
 #include <string>
 #include <utility>
+#include <wx/app.h>
 #include <wx/colour.h>
 #include <set>
 #include "slic3r/GUI/DeviceCore/DevDefs.h"
@@ -18,14 +19,80 @@

 // TODO: remove this include
 #include "slic3r/GUI/DeviceManager.hpp"
+#include "slic3r/GUI/GUI_App.hpp"
 #include "slic3r/GUI/GuiColor.hpp"

 namespace Slic3r
 {
+    // Bambu keeps its fixed external pair (255 main/right, 254 deputy/left) and its two
+    // left/right flags. Every other printer addresses one external virtual tray per live
+    // extruder, so ids 255, 254, 253, ... are extruders 0, 1, 2, ... .
+    static bool _is_bbl_vendor_printer()
+    {
+        return wxTheApp != nullptr && GUI::wxGetApp().preset_bundle != nullptr &&
+               GUI::wxGetApp().preset_bundle->is_bbl_vendor();
+    }
+
+    // Extruder a virtual (external spool) tray id feeds: VIRTUAL_TRAY_MAIN_ID - tray_id.
+    // Returns -1 for an empty, non-numeric or out-of-range id.
+    static int _virtual_tray_extruder_id(const std::string& tray_id)
+    {
+        if (tray_id.empty())
+            return -1;
+        for (char c : tray_id)
+        {
+            if (c < '0' || c > '9')
+                return -1;
+        }
+        try
+        {
+            const int vt_id = std::stoi(tray_id);
+            if (vt_id < 0 || vt_id > VIRTUAL_TRAY_MAIN_ID)
+                return -1;
+            return VIRTUAL_TRAY_MAIN_ID - vt_id;
+        }
+        catch (...)
+        {
+            return -1;
+        }
+    }
+
+    // True when obj->vt_slot actually carries this virtual tray id as a reported spool. A synthetic
+    // topology filler (is_slot_placeholder) only makes the slot addressable and does not count.
+    static bool _has_virtual_tray_slot(const MachineObject* obj, const std::string& tray_id)
+    {
+        if (obj == nullptr || tray_id.empty())
+            return false;
+        for (const auto& tray : obj->vt_slot)
+        {
+            if (!tray.is_slot_placeholder && tray.id == tray_id)
+                return true;
+        }
+        return false;
+    }
+
+    // A generic printer may expose one AMS unit / external slot per extruder. When both legacy
+    // flags of a category are enabled (the sidebar sync call uses both AMS and both external flags)
+    // every extruder participates; when only one side is enabled (SelectMachine's left/right split)
+    // keep to that side's legacy extruder (right = main = 0, left = deputy = 1), so the N slots do
+    // not leak across sides.
+    static bool _generic_extruder_in_selected_side(int extruder_id, bool use_right, bool use_left)
+    {
+        if (use_right && use_left)
+            return true;
+        if (use_right)
+            return extruder_id == MAIN_EXTRUDER_ID;
+        if (use_left)
+            return extruder_id == DEPUTY_EXTRUDER_ID;
+        return false;
+    }
+
    bool DevMappingUtil::is_valid_mapping_result(const MachineObject* obj, std::vector<FilamentInfo>& result, bool check_empty_slot)
    {
        if (result.empty()) return false;

+        const bool is_bbl_vendor = _is_bbl_vendor_printer();
+
        for (int i = 0; i < result.size(); i++)
        {
            // invalid mapping result
@@ -42,8 +109,13 @@ namespace Slic3r
                auto ams_item = obj->GetFilaSystem()->GetAmsById(result[i].ams_id);
                if (ams_item == nullptr)
                {
-                    if ((result[i].ams_id != std::to_string(VIRTUAL_TRAY_MAIN_ID)) &&
-                        (result[i].ams_id != std::to_string(VIRTUAL_TRAY_DEPUTY_ID)))
+                    // A virtual (external spool) tray is not an AMS unit. Bambu keeps its fixed pair;
+                    // a generic printer accepts whichever per-extruder slots it actually reported.
+                    const bool is_virtual_tray = is_bbl_vendor
+                        ? (result[i].ams_id == std::to_string(VIRTUAL_TRAY_MAIN_ID) ||
+                           result[i].ams_id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID))
+                        : _has_virtual_tray_slot(obj, result[i].ams_id);
+                    if (!is_virtual_tray)
                    {
                        result[i].tray_id = -1;
                        return false;
@@ -94,8 +166,11 @@ namespace Slic3r
        result.ams_id = std::to_string(ams_id);
        result.slot_id = std::to_string(slot_id);

-        if (ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID)
+        if (type == DevAms::EXT_SPOOL || ams_id == VIRTUAL_TRAY_MAIN_ID || ams_id == VIRTUAL_TRAY_DEPUTY_ID)
        {
+            // An external spool is addressed by its virtual tray id (255 -> extruder 0, 254 -> 1,
+            // ...); the id is the tray's identity, so it must not fall through to the AMS
+            // ams_id * 4 + slot_id indexing.
            result.tray_id = atoi(tray.id.c_str());
            result.id = atoi(tray.id.c_str());
        }
@@ -126,11 +201,25 @@ namespace Slic3r
        std::map<int, FilamentInfo> tray_filaments; // tray_index : tray_color
        bool  left_nozzle_has_ams = false, right_nozzle_has_ams = false;

+        const bool is_bbl_vendor = _is_bbl_vendor_printer();
+        // Extruders whose AMS filament participates in this mapping. On a generic printer this
+        // carries the per-extruder "nozzle already has AMS" state that the legacy right/left flags
+        // express for Bambu, so the matching external spool can be suppressed.
+        std::set<int> generic_extruders_with_ams;
+
        const auto& ams_list = obj->GetFilaSystem()->GetAmsList();
        for (auto ams = ams_list.begin(); ams != ams_list.end(); ams++)
        {
            std::string ams_id = ams->second->GetAmsId();
            auto        ams_type = ams->second->GetAmsType();
+            const int   ams_id_int = atoi(ams->first.c_str());
+            int         generic_tray_base = 0;
+            if (!is_bbl_vendor) {
+                for (const auto& other : ams_list) {
+                    if (atoi(other.first.c_str()) < ams_id_int)
+                        generic_tray_base += static_cast<int>(other.second->GetTrays().size());
+                }
+            }
            // GetAmsType() maps mixed -> AMS_LITE; recover the mixed type so N9 trays index at 24+slot.
            if (ams_type == DevAms::AMS_LITE && ams->second->IsAmsLiteMixed())
            {
@@ -138,10 +227,16 @@ namespace Slic3r
            }
            for (auto tray = ams->second->GetTrays().begin(); tray != ams->second->GetTrays().end(); tray++)
            {
-                int ams_id = atoi(ams->first.c_str());
+                int ams_id = ams_id_int;
                int tray_id = atoi(tray->first.c_str());
                int tray_index = 0;
-                if (ams_type == DevAms::AMS || ams_type == DevAms::AMS_LITE || ams_type == DevAms::N3F)
+                if (!is_bbl_vendor)
+                {
+                    // Generic units can have different lane counts; index all lanes cumulatively,
+                    // matching the shared tray-index map and sidebar list builder.
+                    tray_index = generic_tray_base + tray_id;
+                }
+                else if (ams_type == DevAms::AMS || ams_type == DevAms::AMS_LITE || ams_type == DevAms::N3F)
                {
                    tray_index = ams_id * 4 + tray_id;
                }
@@ -169,14 +264,18 @@ namespace Slic3r
                if (tray->second->is_tray_info_ready())
                {
                    _parse_tray_info(ams_id, tray_id, ams_type, *(tray->second), info);
+                    // Generic unit lanes use one cumulative index across variable-width units;
+                    // ams_id * 4 + slot_id is only valid for Bambu's fixed four-slot units.
+                    if (!is_bbl_vendor)
+                        info.id = tray_index;
                }

-                //first: left,nozzle=1,map=1   second: right,nozzle=0,map=2
-                bool right_ams_valid = (ams->second->GetBindedExtruderSet().count(MAIN_EXTRUDER_ID) != 0) && map_opt[MappingOption::USE_RIGHT_AMS];
-                bool left_ams_valid = (ams->second->GetBindedExtruderSet().count(DEPUTY_EXTRUDER_ID) != 0) && map_opt[MappingOption::USE_LEFT_AMS];
-                if (right_ams_valid || left_ams_valid)
+                bool ams_valid = false;
+                if (is_bbl_vendor)
                {
-                    tray_filaments.emplace(std::make_pair(tray_index, info));
+                    //first: left,nozzle=1,map=1   second: right,nozzle=0,map=2
+                    bool right_ams_valid = (ams->second->GetBindedExtruderSet().count(MAIN_EXTRUDER_ID) != 0) && map_opt[MappingOption::USE_RIGHT_AMS];
+                    bool left_ams_valid = (ams->second->GetBindedExtruderSet().count(DEPUTY_EXTRUDER_ID) != 0) && map_opt[MappingOption::USE_LEFT_AMS];
                    if (right_ams_valid)
                    {
                        right_nozzle_has_ams = true;
@@ -185,6 +284,25 @@ namespace Slic3r
                    {
                        left_nozzle_has_ams = true;
                    }
+                    ams_valid = right_ams_valid || left_ams_valid;
+                }
+                else
+                {
+                    // A generic unit is bound to its own extruder, so it takes part whenever the
+                    // request covers that extruder.
+                    for (int extruder_id : ams->second->GetBindedExtruderSet())
+                    {
+                        if (_generic_extruder_in_selected_side(extruder_id, map_opt[MappingOption::USE_RIGHT_AMS], map_opt[MappingOption::USE_LEFT_AMS]))
+                        {
+                            ams_valid = true;
+                            generic_extruders_with_ams.insert(extruder_id);
+                        }
+                    }
+                }
+
+                if (ams_valid)
+                {
+                    tray_filaments.emplace(std::make_pair(tray_index, info));
                }
            }
        }
@@ -193,10 +311,21 @@ namespace Slic3r
        {
            for (auto tray : obj->vt_slot)
            {
-                bool right_ext_valid = (tray.id == std::to_string(VIRTUAL_TRAY_MAIN_ID) && map_opt[MappingOption::USE_RIGHT_EXT]);
-                bool left_ext_valid = (tray.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID) && map_opt[MappingOption::USE_LEFT_EXT]);
-                if (right_ext_valid || left_ext_valid)
+                // A synthetic topology filler is not a reported external spool, so it is never a
+                // mapping candidate. Bambu keeps its fixed reported pair.
+                if (!is_bbl_vendor && tray.is_slot_placeholder)
                {
+                    continue;
+                }
+                if (is_bbl_vendor)
+                {
+                    // Bambu keeps its fixed pair and the two left/right external flags.
+                    const bool right_ext_valid = (tray.id == std::to_string(VIRTUAL_TRAY_MAIN_ID) && map_opt[MappingOption::USE_RIGHT_EXT]);
+                    const bool left_ext_valid = (tray.id == std::to_string(VIRTUAL_TRAY_DEPUTY_ID) && map_opt[MappingOption::USE_LEFT_EXT]);
+                    if (!right_ext_valid && !left_ext_valid)
+                    {
+                        continue;
+                    }
                    if (nozzle_has_ams_then_ignore_ext)
                    {
                        if (right_ext_valid && right_nozzle_has_ams)
@@ -208,10 +337,31 @@ namespace Slic3r
                            continue;
                        }
                    }
-                    FilamentInfo info;
-                    _parse_tray_info(atoi(tray.id.c_str()), 0, DevAms::EXT_SPOOL, tray, info);
-                    tray_filaments.emplace(std::make_pair(info.tray_id, info));
                }
+                else
+                {
+                    // Generic: every present virtual tray is the external spool of the extruder it
+                    // addresses (VIRTUAL_TRAY_MAIN_ID - tray.id): 255 -> 0, 254 -> 1, ... . Keep to
+                    // the selected side when only one legacy flag is enabled, and drop the spool when
+                    // its extruder already has AMS filament in this mapping and suppression is on.
+                    const int extruder_id = _virtual_tray_extruder_id(tray.id);
+                    if (extruder_id < 0)
+                    {
+                        continue;
+                    }
+                    if (!_generic_extruder_in_selected_side(extruder_id, map_opt[MappingOption::USE_RIGHT_EXT], map_opt[MappingOption::USE_LEFT_EXT]))
+                    {
+                        continue;
+                    }
+                    if (nozzle_has_ams_then_ignore_ext && generic_extruders_with_ams.count(extruder_id) != 0)
+                    {
+                        continue;
+                    }
+                }
+
+                FilamentInfo info;
+                _parse_tray_info(atoi(tray.id.c_str()), 0, DevAms::EXT_SPOOL, tray, info);
+                tray_filaments.emplace(std::make_pair(info.tray_id, info));
            }
        }

@@ -412,4 +562,4 @@ namespace Slic3r
        return 0;
    }

-}
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Ian Chua	f38f2bddec	fix: test fixture	2026-10-16 22:23:42 +08:00
Ian Chua	1d291f6f04	fix: clang-tidy	2026-10-16 21:28:37 +08:00
Ian Chua	5390b789f1	fix: nozzle & preset sync	2026-10-16 20:51:22 +08:00
Ian Chua	f68fbfed58	feat: update happy hare parsing	2026-10-16 20:48:57 +08:00
Ian Chua	7ed4095b20	fix: clang-tidy	2026-10-15 16:06:50 +08:00
Ian Chua	ee1cc1b227	Merge branch 'feat/ams-parsing' into feat/generic-extruders-and-ams	2026-10-15 16:05:00 +08:00
Ian Chua	46096416cd	Merge branch 'main' into feat/generic-n-extruders	2026-10-15 16:04:30 +08:00
Ian Chua	74fe2b7996	Merge branch 'main' into feat/generic-n-extruders	2026-10-15 14:45:26 +08:00
Ian Chua	38f649fc00	Merge branch 'main' into feat/ams-parsing	2026-10-15 14:42:59 +08:00
peachismomo	23f6771dcb	fix: parse AFC lane data and non-bambu ams tray indices correctly	2026-10-11 20:11:47 +08:00
Ian Chua	aebc0a2979	fix: change ams type when parsing AFC mmu	2026-10-09 18:27:14 +08:00
Ian Chua	6f0ec60d21	feat: update happy hare parsing	2026-10-08 21:26:00 +08:00
Ian Chua	8e43a2ac13	fix: center external spool	2026-10-08 21:19:00 +08:00
Ian Chua	6b366ad8a9	fix: sync_ams_list should drop placeholder filaments	2026-10-08 20:42:11 +08:00
Ian Chua	7d8261668e	fix: use extruder count for bbl and m_nozzle_book for non bbl	2026-10-08 20:29:47 +08:00
Ian Chua	00127beffa	fix: use multi-nozzle AMS layout for non-Bambu printers at any extruder count	2026-10-08 19:26:43 +08:00
Lam Wei Lun	927eb9922c	Map slot id directly	2026-10-08 18:37:09 +08:00
Ian Chua	3d62769664	feat: expand filament parsing in MoonrakerPrinterAgent	2026-10-08 17:46:01 +08:00
Ian Chua	e5e30ee0e8	fix: harden generic N-extruder device model and status/AMS UI, add N-toolhead ExtruderImage sizing, tests, and HLSD	2026-10-08 17:39:44 +08:00
Ian Chua	7515fb480f	fix: remove dead code	2026-10-08 15:56:20 +08:00
Ian Chua	acc1d6fd21	Merge branch 'main' into feat/generic-n-extruders	2026-10-08 14:49:50 +08:00
Ian Chua	6ca0fc5ef1	fix: clang-tidy	2026-10-07 19:33:58 +08:00
Ian Chua	bcf7d078cd	Merge branch 'main' into feat/generic-n-extruders	2026-10-07 19:25:52 +08:00
Ian Chua	15fc96fca7	Merge branch 'main' into feat/generic-n-extruders	2026-10-07 19:25:35 +08:00
Ian Chua	1fffda0533	chore: add tests and HLSD	2026-10-07 19:05:06 +08:00
Ian Chua	33e26a127e	fix: warn when toolhead count differs from the selected printer preset's nozzle_diameter count	2026-10-07 18:40:41 +08:00
Ian Chua	6dd0cb9eba	fix: harden generic N-extruder device paths	2026-10-07 18:30:49 +08:00
Ian Chua	9bf0fc2a8e	test: reset virtual trays in the generic AMS tray index map case	2026-10-06 20:53:46 +08:00
Ian Chua	5bf6db95b3	fix: clang-tidy	2026-10-06 19:56:53 +08:00
Ian Chua	0feb87b417	feat: generic N extruders, multiple AMS and AMS slots	2026-10-06 19:22:10 +08:00