Merge branch 'main' into feature/update_wipetower

2026-09-28 19:31:22 +00:00 · 2026-07-27 00:51:29 +08:00
parent bc016af1c9 ed86efcf56
commit 5792fef805
45 changed files with 2476 additions and 579 deletions
@@ -423,6 +423,7 @@ endif ()
 include(OCCT/OCCT.cmake)
 include(OpenCV/OpenCV.cmake)
 include(python3/python3.cmake)
+include(wxInspector/wxInspector.cmake)

 set(_dep_list
    dep_Boost
@@ -446,6 +447,7 @@ set(_dep_list
    ${EXPAT_PKG}
    dep_libnoise
    dep_python3
+    dep_wxInspector
    )

 if (MSVC)
@@ -0,0 +1,13 @@
+orcaslicer_add_cmake_project(
+    wxInspector
+    URL https://github.com/Noisyfox/wxInspector/archive/refs/tags/v1.0.0.zip
+    URL_HASH SHA256=0ba163956f2d468b19a91b96c5aba66ee9610843ea41dda628ea44cdafde7db7
+    DEPENDS ${WXWIDGETS_PKG}
+    CMAKE_ARGS
+        -DCMAKE_CXX_FLAGS="-DwxDEBUG_LEVEL=0"
+        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+)
+
+if (MSVC)
+    add_debug_dep(dep_wxInspector)
+endif ()
@@ -26,6 +26,7 @@ orcaslicer_add_cmake_project(
    GIT_REPOSITORY "https://github.com/SoftFever/Orca-deps-wxWidgets"
    GIT_TAG v3.3.2
    GIT_SHALLOW ON
+    GIT_SUBMODULES 3rdparty/catch 3rdparty/pcre 3rdparty/libwebp
    DEPENDS ${PNG_PKG} ${ZLIB_PKG} ${EXPAT_PKG} ${JPEG_PKG}
    CMAKE_ARGS
        -DwxBUILD_PRECOMP=ON
@@ -0,0 +1,111 @@
+# Move `wxInspectable` into `DPIAware` — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Move `wxInspector::wxInspectable` from individual leaf classes into the common `DPIAware<P>` template so every DPIAware widget is automatically inspectable and gets the inspector keyboard shortcut.
+
+**Architecture:** `DPIAware<P>` gains `wxInspector::wxInspectable` as a second base class and calls `SetupInspectorAccelerator(this)` in its constructor. `DPIDialog` and `MainFrame` drop their now-redundant `wxInspectable` inheritance and `SetupInspectorAccelerator` calls.
+
+**Tech Stack:** C++17, wxWidgets, wxInspector
+
+## Global Constraints
+
+- Build with `D:\VisualStudio\2026\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe`
+- Use `--config RelWithDebInfo` for all builds
+- Cross-platform: must compile on Windows, macOS, and Linux
+- Match existing code style: PascalCase classes, `#pragma once`
+- Do NOT commit files under `.superpowers/`
+- Do NOT commit `task.md`
+
+---
+
+### Task 1: Move `wxInspectable` and `SetupInspectorAccelerator` into `DPIAware<P>`
+
+**Files:**
+- Modify: `src/slic3r/GUI/GUI_Utils.hpp:92` (DPIAware template — add wxInspectable base + SetupInspectorAccelerator call)
+- Modify: `src/slic3r/GUI/GUI_Utils.hpp:276` (DPIDialog — drop wxInspectable + SetupInspectorAccelerator)
+- Modify: `src/slic3r/GUI/MainFrame.hpp:96` (MainFrame — drop wxInspectable)
+- Modify: `src/slic3r/GUI/MainFrame.cpp:304` (MainFrame constructor — drop SetupInspectorAccelerator)
+
+**Interfaces:**
+- Consumes: Nothing (standalone refactor)
+- Produces: All DPIAware widgets automatically inherit `wxInspector::wxInspectable` and get Ctrl+Shift+I accelerator
+
+- [ ] **Step 1: Add `wxInspectable` to `DPIAware<P>` and call `SetupInspectorAccelerator`**
+
+In `src/slic3r/GUI/GUI_Utils.hpp`, line 92, change the base class:
+
+```cpp
+// Before:
+template<class P> class DPIAware : public P
+// After:
+template<class P> class DPIAware : public P, public wxInspector::wxInspectable
+```
+
+In the constructor body of `DPIAware<P>`, after `this->CenterOnParent();` (currently line 110), add:
+
+```cpp
+SetupInspectorAccelerator(this);
+```
+
+(`<wx/inspector/inspector.h>` is already included at line 23.)
+
+- [ ] **Step 2: Remove redundant `wxInspectable` and `SetupInspectorAccelerator` from `DPIDialog`**
+
+In `src/slic3r/GUI/GUI_Utils.hpp`, line 276, change:
+
+```cpp
+// Before:
+class DPIDialog : public DPIAware<wxDialog>, public wxInspector::wxInspectable
+// After:
+class DPIDialog : public DPIAware<wxDialog>
+```
+
+In the `DPIDialog` constructor body, remove the `SetupInspectorAccelerator(this);` line (currently line 286). The rest of the constructor stays.
+
+- [ ] **Step 3: Remove redundant `wxInspectable` from `MainFrame`**
+
+In `src/slic3r/GUI/MainFrame.hpp`, line 96, change:
+
+```cpp
+// Before:
+class MainFrame : public DPIFrame, public wxInspector::wxInspectable
+// After:
+class MainFrame : public DPIFrame
+```
+
+`MainFrame` now gets `wxInspectable` through `DPIFrame` → `DPIAware<wxFrame>`.
+
+- [ ] **Step 4: Remove redundant `SetupInspectorAccelerator` from `MainFrame` constructor**
+
+In `src/slic3r/GUI/MainFrame.cpp`, line 304, remove the line:
+
+```cpp
+SetupInspectorAccelerator(this);
+```
+
+It is now called automatically by the `DPIAware<wxFrame>` constructor.
+
+- [ ] **Step 5: Build to verify compilation**
+
+```powershell
+$cmakePath = "D:\VisualStudio\2026\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe"
+& $cmakePath --build . --config RelWithDebInfo --target ALL_BUILD -- -m
+```
+
+Expected: Build succeeds with zero new errors or warnings.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/slic3r/GUI/GUI_Utils.hpp src/slic3r/GUI/MainFrame.hpp src/slic3r/GUI/MainFrame.cpp
+git commit -m "refactor: move wxInspectable and SetupInspectorAccelerator into DPIAware
+
+DPIAware<P> now inherits wxInspector::wxInspectable and calls
+SetupInspectorAccelerator in its constructor, making all DPIAware
+widgets automatically appear in the inspector tree with the
+Ctrl+Shift+I shortcut. Remove redundant wxInspectable inheritance
+and SetupInspectorAccelerator calls from DPIDialog and MainFrame.
+
+Co-Authored-By: Claude <noreply@anthropic.com>"
+```
@@ -0,0 +1,753 @@
+# wxInspector Plugins for OrcaSlicer — Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Build two wxInspector plugins (DPIAware + CustomWidgets) that expose OrcaSlicer custom control properties in the inspector's property grid.
+
+**Architecture:** Two plugins in a shared folder under `src/slic3r/Utils/wxInspectorPlugins/`. DPIAwarePlugin uses `dynamic_cast<DPIFrame*>/<DPIDialog*>` for detection; CustomWidgetsPlugin uses per-type `dynamic_cast`. Both registered as static singletons via a single inline function in `Registration.hpp`, called from `MainFrame` constructor.
+
+**Tech Stack:** C++17, wxWidgets, wxInspector plugin API (`wx/inspector/plugin.h`, `wx/inspector/inspector.h`), OrcaSlicer custom widget headers
+
+## Global Constraints
+
+- Plugins placed under `src/slic3r/Utils/wxInspectorPlugins/`
+- Build with `D:\VisualStudio\2026\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe`
+- Minimal source changes: only trivial (one-line) getters/setters added to existing classes
+- Cross-platform: must compile on Windows, macOS, and Linux
+- Match existing code style: PascalCase classes, snake_case functions, `#pragma once`
+
+---
+
+### Task 1: Add getters/setters to existing Orca widget headers
+
+**Files:**
+- Modify: `src/slic3r/GUI/GUI_Utils.hpp` (DPIAware template — add 4 methods)
+- Modify: `src/slic3r/GUI/Widgets/Button.hpp` (add 3 getters)
+- Modify: `src/slic3r/GUI/Widgets/CheckBox.hpp` (add 1 getter)
+- Modify: `src/slic3r/GUI/Widgets/TextInput.hpp` (add 1 getter)
+- Modify: `src/slic3r/GUI/Widgets/LabeledStaticBox.hpp` (add 4 getter declarations)
+- Modify: `src/slic3r/GUI/Widgets/LabeledStaticBox.cpp` (add 4 getter implementations)
+
+**Interfaces:**
+- Consumes: Nothing (prerequisite for all other tasks)
+- Produces:
+  - `DPIAware<P>::set_scale_factor(float)`, `DPIAware<P>::set_prev_scale_factor(float)`, `DPIAware<P>::set_em_unit(int)`, `DPIAware<P>::force_rescale() const`
+  - `Button::GetStyle()`, `Button::GetType()`, `Button::IsSelected()`
+  - `CheckBox::IsHalfChecked()`
+  - `TextInput::GetCornerRadius()`
+  - `LabeledStaticBox::GetCornerRadius()`, `LabeledStaticBox::GetBorderWidth()`, `LabeledStaticBox::GetBorderColor()`, `LabeledStaticBox::GetScale()`
+
+- [ ] **Step 1: Add DPIAware setters/getter in GUI_Utils.hpp**
+
+After line 184 (`float prev_scale_factor() const { return m_prev_scale_factor; }`), add:
+
+```cpp
+void  set_scale_factor(float v)      { m_scale_factor = v; }
+void  set_prev_scale_factor(float v) { m_prev_scale_factor = v; }
+void  set_em_unit(int v)             { m_em_unit = v; }
+bool  force_rescale() const          { return m_force_rescale; }
+```
+
+- [ ] **Step 2: Add Button getters in Button.hpp**
+
+After line 79 (`void SetSelected(bool selected = true) { m_selected = selected; }`), add:
+
+```cpp
+ButtonStyle GetStyle() const { return m_style; }
+ButtonType  GetType() const  { return m_type; }
+bool IsSelected() const      { return m_selected; }
+```
+
+- [ ] **Step 3: Add CheckBox getter in CheckBox.hpp**
+
+After line 16 (`void SetHalfChecked(bool value = true);`), add:
+
+```cpp
+bool IsHalfChecked() const { return m_half_checked; }
+```
+
+- [ ] **Step 4: Add TextInput getter in TextInput.hpp**
+
+After line 44 (`void SetCornerRadius(double radius);`), add:
+
+```cpp
+int GetCornerRadius() const { return static_cast<int>(radius); }
+```
+
+(Note: `radius` is inherited from `StaticBox` which has it as a protected `double` member.)
+
+- [ ] **Step 5: Add LabeledStaticBox getter declarations in LabeledStaticBox.hpp**
+
+After line 46 (`bool Enable(bool enable) override;`), add:
+
+```cpp
+int        GetCornerRadius() const { return m_radius; }
+int        GetBorderWidth() const  { return m_border_width; }
+StateColor GetBorderColor() const  { return border_color; }
+float      GetScale() const        { return m_scale; }
+```
+
+(Note: all of `m_radius`, `m_border_width`, `border_color`, `m_scale` are protected members, accessible to inline methods.)
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add src/slic3r/GUI/GUI_Utils.hpp src/slic3r/GUI/Widgets/Button.hpp src/slic3r/GUI/Widgets/CheckBox.hpp src/slic3r/GUI/Widgets/TextInput.hpp src/slic3r/GUI/Widgets/LabeledStaticBox.hpp
+git commit -m "feat: add getters/setters for wxInspector plugin access
+
+Add minimal public accessors to DPIAware (set_scale_factor,
+set_prev_scale_factor, set_em_unit, force_rescale), Button
+(GetStyle, GetType, IsSelected), CheckBox (IsHalfChecked),
+TextInput (GetCornerRadius), and LabeledStaticBox
+(GetCornerRadius, GetBorderWidth, GetBorderColor, GetScale)."
+```
+
+---
+
+### Task 2: Create Registration helper header
+
+**Files:**
+- Create: `src/slic3r/Utils/wxInspectorPlugins/Registration.hpp`
+
+**Interfaces:**
+- Consumes: Nothing (forward-declares plugin classes)
+- Produces: `RegisterOrcaInspectorPlugins()`
+
+- [ ] **Step 1: Create directory**
+
+```bash
+mkdir -p src/slic3r/Utils/wxInspectorPlugins
+```
+
+- [ ] **Step 2: Write Registration.hpp**
+
+```cpp
+#pragma once
+
+namespace wxInspector {
+class wxInspectorPlugin;
+void RegisterPlugin(wxInspectorPlugin* plugin);
+}
+
+// Forward declare our plugins
+class DPIAwarePlugin;
+class CustomWidgetsPlugin;
+
+inline void RegisterOrcaInspectorPlugins()
+{
+    static DPIAwarePlugin          dpiaware;
+    static CustomWidgetsPlugin     customWidgets;
+    wxInspector::RegisterPlugin(&dpiaware);
+    wxInspector::RegisterPlugin(&customWidgets);
+}
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/slic3r/Utils/wxInspectorPlugins/Registration.hpp
+git commit -m "feat: add wxInspector plugin registration helper
+
+Add RegisterOrcaInspectorPlugins() inline function that creates
+and registers the DPIAwarePlugin and CustomWidgetsPlugin as
+static instances (matching wxInspector's built-in pattern)."
+```
+
+---
+
+### Task 3: Create DPIAwarePlugin
+
+**Files:**
+- Create: `src/slic3r/Utils/wxInspectorPlugins/DPIAwarePlugin.hpp`
+- Create: `src/slic3r/Utils/wxInspectorPlugins/DPIAwarePlugin.cpp`
+
+**Interfaces:**
+- Consumes: Task 1 (DPIAware getters/setters), Task 2 (registration pattern)
+- Produces: `class DPIAwarePlugin : public wxInspector::wxInspectorPlugin`
+
+- [ ] **Step 1: Write DPIAwarePlugin.hpp**
+
+```cpp
+#pragma once
+
+#include <wx/inspector/plugin.h>
+
+class DPIAwarePlugin : public wxInspector::wxInspectorPlugin
+{
+public:
+    wxString GetName() const override;
+
+    bool CanProvideProperties(wxClassInfo* info) override;
+
+    wxVector<wxInspector::PropertyDef> GetProperties(
+        wxInspector::InspectableObject& obj) override;
+};
+```
+
+- [ ] **Step 2: Write DPIAwarePlugin.cpp**
+
+```cpp
+#include "DPIAwarePlugin.hpp"
+
+#include "slic3r/GUI/GUI_Utils.hpp" // DPIFrame, DPIDialog, DPIAware<P>
+
+#include <wx/window.h>
+
+namespace {
+
+template<typename T>
+void addDPIProps(T* dpi, wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Scale Factor", "DPI Scaling", PropertyType::String,
+        wxString::Format("%.2f", dpi->scale_factor()), false, {},
+        [dpi]() { return wxString::Format("%.2f", dpi->scale_factor()); },
+        [dpi](const wxString& v) {
+            double val;
+            if (wxSscanf(v, "%lf", &val) != 1) return false;
+            dpi->set_scale_factor((float) val);
+            return true;
+        }});
+
+    props.push_back({"Prev Scale Factor", "DPI Scaling", PropertyType::String,
+        wxString::Format("%.2f", dpi->prev_scale_factor()), false, {},
+        [dpi]() { return wxString::Format("%.2f", dpi->prev_scale_factor()); },
+        [dpi](const wxString& v) {
+            double val;
+            if (wxSscanf(v, "%lf", &val) != 1) return false;
+            dpi->set_prev_scale_factor((float) val);
+            return true;
+        }});
+
+    props.push_back({"EM Unit", "DPI Scaling", PropertyType::Integer,
+        wxString::Format("%d", dpi->em_unit()), false, {},
+        [dpi]() { return wxString::Format("%d", dpi->em_unit()); },
+        [dpi](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            dpi->set_em_unit((int) val);
+            return true;
+        }});
+
+    props.push_back({"Normal Font", "DPI Scaling", PropertyType::ReadOnly,
+        dpi->normal_font().GetNativeFontInfoDesc(), true, {},
+        [dpi]() { return dpi->normal_font().GetNativeFontInfoDesc(); },
+        nullptr});
+
+    props.push_back({"Force Rescale", "DPI Scaling", PropertyType::Boolean,
+        dpi->force_rescale() ? "true" : "false", true, {},
+        [dpi]() { return dpi->force_rescale() ? "true" : "false"; },
+        nullptr});
+}
+
+} // anonymous namespace
+
+wxString DPIAwarePlugin::GetName() const
+{
+    return "OrcaDPIAware";
+}
+
+bool DPIAwarePlugin::CanProvideProperties(wxClassInfo* info)
+{
+    return info->IsKindOf(CLASSINFO(wxWindow));
+}
+
+wxVector<wxInspector::PropertyDef> DPIAwarePlugin::GetProperties(
+    wxInspector::InspectableObject& obj)
+{
+    wxVector<wxInspector::PropertyDef> props;
+    wxWindow* win = obj.AsWindow();
+    if (!win) return props;
+
+    if (auto* frame = dynamic_cast<DPIFrame*>(win)) {
+        addDPIProps(frame, props);
+    } else if (auto* dlg = dynamic_cast<DPIDialog*>(win)) {
+        addDPIProps(dlg, props);
+    }
+
+    return props;
+}
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add src/slic3r/Utils/wxInspectorPlugins/DPIAwarePlugin.hpp src/slic3r/Utils/wxInspectorPlugins/DPIAwarePlugin.cpp
+git commit -m "feat: add DPIAware wxInspector plugin
+
+Exposes DPI scaling properties (scale_factor, prev_scale_factor,
+em_unit, normal_font, force_rescale) on DPIFrame and DPIDialog
+widgets. Uses dynamic_cast for detection and a template helper
+to capture the correct static type for lambda accessors."
+```
+
+---
+
+### Task 4: Create CustomWidgetsPlugin
+
+**Files:**
+- Create: `src/slic3r/Utils/wxInspectorPlugins/CustomWidgetsPlugin.hpp`
+- Create: `src/slic3r/Utils/wxInspectorPlugins/CustomWidgetsPlugin.cpp`
+
+**Interfaces:**
+- Consumes: Task 1 (all widget getters), Task 2 (registration pattern)
+- Produces: `class CustomWidgetsPlugin : public wxInspector::wxInspectorPlugin`
+
+- [ ] **Step 1: Write CustomWidgetsPlugin.hpp**
+
+```cpp
+#pragma once
+
+#include <wx/inspector/plugin.h>
+
+class CustomWidgetsPlugin : public wxInspector::wxInspectorPlugin
+{
+public:
+    wxString GetName() const override;
+
+    bool CanProvideProperties(wxClassInfo* info) override;
+
+    wxVector<wxInspector::PropertyDef> GetProperties(
+        wxInspector::InspectableObject& obj) override;
+
+private:
+    void addButtonProps(class Button* btn,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addCheckBoxProps(class CheckBox* cb,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addTextInputProps(class TextInput* ti,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addSwitchButtonProps(class SwitchButton* sb,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addProgressBarProps(class ProgressBar* pb,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addLabelProps(class Label* lbl,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addLabeledStaticBoxProps(class LabeledStaticBox* lsb,
+        wxVector<wxInspector::PropertyDef>& props);
+};
+```
+
+- [ ] **Step 2: Write CustomWidgetsPlugin.cpp — includes and GetName/CanProvideProperties**
+
+```cpp
+#include "CustomWidgetsPlugin.hpp"
+
+#include "slic3r/GUI/Widgets/Button.hpp"
+#include "slic3r/GUI/Widgets/CheckBox.hpp"
+#include "slic3r/GUI/Widgets/TextInput.hpp"
+#include "slic3r/GUI/Widgets/SwitchButton.hpp"
+#include "slic3r/GUI/Widgets/ProgressBar.hpp"
+#include "slic3r/GUI/Widgets/Label.hpp"
+#include "slic3r/GUI/Widgets/LabeledStaticBox.hpp"
+
+#include <wx/window.h>
+#include <wx/tglbtn.h>
+
+wxString CustomWidgetsPlugin::GetName() const
+{
+    return "OrcaCustomWidgets";
+}
+
+bool CustomWidgetsPlugin::CanProvideProperties(wxClassInfo* info)
+{
+    return info->IsKindOf(CLASSINFO(wxWindow));
+}
+
+wxVector<wxInspector::PropertyDef> CustomWidgetsPlugin::GetProperties(
+    wxInspector::InspectableObject& obj)
+{
+    wxVector<wxInspector::PropertyDef> props;
+    wxWindow* win = obj.AsWindow();
+    if (!win) return props;
+
+    if (auto* btn = dynamic_cast<Button*>(win))
+        addButtonProps(btn, props);
+    if (auto* cb = dynamic_cast<CheckBox*>(win))
+        addCheckBoxProps(cb, props);
+    if (auto* ti = dynamic_cast<TextInput*>(win))
+        addTextInputProps(ti, props);
+    if (auto* sb = dynamic_cast<SwitchButton*>(win))
+        addSwitchButtonProps(sb, props);
+    if (auto* pb = dynamic_cast<ProgressBar*>(win))
+        addProgressBarProps(pb, props);
+    if (auto* lbl = dynamic_cast<Label*>(win))
+        addLabelProps(lbl, props);
+    if (auto* lsb = dynamic_cast<LabeledStaticBox*>(win))
+        addLabeledStaticBoxProps(lsb, props);
+
+    return props;
+}
+```
+
+- [ ] **Step 3: Write CustomWidgetsPlugin.cpp — addButtonProps**
+
+```cpp
+void CustomWidgetsPlugin::addButtonProps(Button* btn,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    wxVector<wxString> styleChoices;
+    styleChoices.push_back("Regular");
+    styleChoices.push_back("Confirm");
+    styleChoices.push_back("Alert");
+    styleChoices.push_back("Disabled");
+
+    auto styleToStr = [](ButtonStyle s) -> wxString {
+        switch (s) {
+            case ButtonStyle::Regular:  return "Regular";
+            case ButtonStyle::Confirm:  return "Confirm";
+            case ButtonStyle::Alert:    return "Alert";
+            case ButtonStyle::Disabled: return "Disabled";
+        }
+        return "Regular";
+    };
+
+    props.push_back({"Button Style", "Orca Button", PropertyType::Choice,
+        styleToStr(btn->GetStyle()), false, styleChoices,
+        [btn, styleToStr]() { return styleToStr(btn->GetStyle()); },
+        [btn](const wxString& v) {
+            ButtonStyle s = ButtonStyle::Regular;
+            if (v == "Confirm")       s = ButtonStyle::Confirm;
+            else if (v == "Alert")    s = ButtonStyle::Alert;
+            else if (v == "Disabled") s = ButtonStyle::Disabled;
+            btn->SetStyle(s, btn->GetType());
+            return true;
+        }});
+
+    wxVector<wxString> typeChoices;
+    typeChoices.push_back("Compact");
+    typeChoices.push_back("Window");
+    typeChoices.push_back("Choice");
+    typeChoices.push_back("Parameter");
+    typeChoices.push_back("Icon");
+    typeChoices.push_back("Expanded");
+
+    auto typeToStr = [](ButtonType t) -> wxString {
+        switch (t) {
+            case ButtonType::Compact:   return "Compact";
+            case ButtonType::Window:    return "Window";
+            case ButtonType::Choice:    return "Choice";
+            case ButtonType::Parameter: return "Parameter";
+            case ButtonType::Icon:      return "Icon";
+            case ButtonType::Expanded:  return "Expanded";
+        }
+        return "Compact";
+    };
+
+    props.push_back({"Button Type", "Orca Button", PropertyType::Choice,
+        typeToStr(btn->GetType()), false, typeChoices,
+        [btn, typeToStr]() { return typeToStr(btn->GetType()); },
+        [btn](const wxString& v) {
+            ButtonType t = ButtonType::Compact;
+            if (v == "Window")       t = ButtonType::Window;
+            else if (v == "Choice")    t = ButtonType::Choice;
+            else if (v == "Parameter") t = ButtonType::Parameter;
+            else if (v == "Icon")      t = ButtonType::Icon;
+            else if (v == "Expanded")  t = ButtonType::Expanded;
+            btn->SetStyle(btn->GetStyle(), t);
+            return true;
+        }});
+
+    props.push_back({"Selected", "Orca Button", PropertyType::Boolean,
+        btn->IsSelected() ? "true" : "false", false, {},
+        [btn]() { return btn->IsSelected() ? "true" : "false"; },
+        [btn](const wxString& v) {
+            btn->SetSelected(v == "true");
+            btn->Refresh();
+            return true;
+        }});
+}
+```
+
+- [ ] **Step 4: Write CustomWidgetsPlugin.cpp — addCheckBoxProps**
+
+```cpp
+void CustomWidgetsPlugin::addCheckBoxProps(CheckBox* cb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Half Checked", "Orca CheckBox", PropertyType::Boolean,
+        cb->IsHalfChecked() ? "true" : "false", false, {},
+        [cb]() { return cb->IsHalfChecked() ? "true" : "false"; },
+        [cb](const wxString& v) {
+            cb->SetHalfChecked(v == "true");
+            return true;
+        }});
+}
+```
+
+- [ ] **Step 5: Write CustomWidgetsPlugin.cpp — addTextInputProps**
+
+```cpp
+void CustomWidgetsPlugin::addTextInputProps(TextInput* ti,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Label", "Orca TextInput", PropertyType::String,
+        ti->GetLabel(), false, {},
+        [ti]() { return ti->GetLabel(); },
+        [ti](const wxString& v) { ti->SetLabel(v); return true; }});
+
+    props.push_back({"Text Value", "Orca TextInput", PropertyType::String,
+        ti->GetTextCtrl()->GetValue(), false, {},
+        [ti]() { return ti->GetTextCtrl()->GetValue(); },
+        [ti](const wxString& v) { ti->GetTextCtrl()->SetValue(v); return true; }});
+
+    props.push_back({"Corner Radius", "Orca TextInput", PropertyType::Integer,
+        wxString::Format("%d", ti->GetCornerRadius()), false, {},
+        [ti]() { return wxString::Format("%d", ti->GetCornerRadius()); },
+        [ti](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            ti->SetCornerRadius((double) val);
+            ti->Refresh();
+            return true;
+        }});
+}
+```
+
+- [ ] **Step 6: Write CustomWidgetsPlugin.cpp — addSwitchButtonProps**
+
+```cpp
+void CustomWidgetsPlugin::addSwitchButtonProps(SwitchButton* sb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Value", "Orca SwitchButton", PropertyType::Boolean,
+        sb->GetValue() ? "true" : "false", false, {},
+        [sb]() { return sb->GetValue() ? "true" : "false"; },
+        [sb](const wxString& v) {
+            sb->SetValue(v == "true");
+            return true;
+        }});
+}
+```
+
+(Note: `GetValue()` and `SetValue()` are inherited from `wxBitmapToggleButton` → `wxToggleButton`.)
+
+- [ ] **Step 7: Write CustomWidgetsPlugin.cpp — addProgressBarProps**
+
+```cpp
+void CustomWidgetsPlugin::addProgressBarProps(ProgressBar* pb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Proportion", "Orca ProgressBar", PropertyType::String,
+        wxString::Format("%.2f", pb->m_proportion), false, {},
+        [pb]() { return wxString::Format("%.2f", pb->m_proportion); },
+        [pb](const wxString& v) {
+            double val;
+            if (wxSscanf(v, "%lf", &val) != 1) return false;
+            pb->m_proportion = val;
+            pb->Refresh();
+            return true;
+        }});
+
+    props.push_back({"Show Number", "Orca ProgressBar", PropertyType::Boolean,
+        pb->m_shownumber ? "true" : "false", false, {},
+        [pb]() { return pb->m_shownumber ? "true" : "false"; },
+        [pb](const wxString& v) {
+            pb->m_shownumber = (v == "true");
+            pb->Refresh();
+            return true;
+        }});
+}
+```
+
+(Note: `m_proportion` and `m_shownumber` are public members on `ProgressBar`.)
+
+- [ ] **Step 8: Write CustomWidgetsPlugin.cpp — addLabelProps**
+
+```cpp
+void CustomWidgetsPlugin::addLabelProps(Label* lbl,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    bool isHyperlink = (lbl->GetWindowStyleFlag() & 0x0020) != 0; // LB_HYPERLINK
+
+    props.push_back({"Is Hyperlink", "Orca Label", PropertyType::Boolean,
+        isHyperlink ? "true" : "false", true, {},
+        [lbl]() {
+            return (lbl->GetWindowStyleFlag() & 0x0020) ? "true" : "false";
+        },
+        nullptr});
+
+    props.push_back({"Font Point Size", "Orca Label", PropertyType::ReadOnly,
+        wxString::Format("%d", lbl->GetFont().GetPointSize()), true, {},
+        [lbl]() {
+            return wxString::Format("%d", lbl->GetFont().GetPointSize());
+        },
+        nullptr});
+}
+```
+
+- [ ] **Step 9: Write CustomWidgetsPlugin.cpp — addLabeledStaticBoxProps**
+
+```cpp
+void CustomWidgetsPlugin::addLabeledStaticBoxProps(LabeledStaticBox* lsb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Corner Radius", "LabeledStaticBox", PropertyType::Integer,
+        wxString::Format("%d", lsb->GetCornerRadius()), false, {},
+        [lsb]() { return wxString::Format("%d", lsb->GetCornerRadius()); },
+        [lsb](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            lsb->SetCornerRadius((int) val);
+            return true;
+        }});
+
+    props.push_back({"Border Width", "LabeledStaticBox", PropertyType::Integer,
+        wxString::Format("%d", lsb->GetBorderWidth()), false, {},
+        [lsb]() { return wxString::Format("%d", lsb->GetBorderWidth()); },
+        [lsb](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            lsb->SetBorderWidth((int) val);
+            return true;
+        }});
+
+    // Border Color: display as hex string
+    wxColour bc = lsb->GetBorderColor().colorForStates(0);
+    props.push_back({"Border Color", "LabeledStaticBox", PropertyType::String,
+        bc.GetAsString(wxC2S_HTML_SYNTAX), false, {},
+        [lsb]() {
+            return lsb->GetBorderColor()
+                .colorForStates(0)
+                .GetAsString(wxC2S_HTML_SYNTAX);
+        },
+        [lsb](const wxString& v) {
+            wxColour c(v);
+            if (!c.IsOk()) return false;
+            lsb->SetBorderColor(StateColor(c));
+            return true;
+        }});
+
+    props.push_back({"Scale", "LabeledStaticBox", PropertyType::ReadOnly,
+        wxString::Format("%.2f", lsb->GetScale()), true, {},
+        [lsb]() { return wxString::Format("%.2f", lsb->GetScale()); },
+        nullptr});
+}
+```
+
+- [ ] **Step 10: Commit**
+
+```bash
+git add src/slic3r/Utils/wxInspectorPlugins/CustomWidgetsPlugin.hpp src/slic3r/Utils/wxInspectorPlugins/CustomWidgetsPlugin.cpp
+git commit -m "feat: add OrcaCustomWidgets wxInspector plugin
+
+Exposes Orca-specific properties on 7 widget types:
+- Button: Style, Type, Selected
+- CheckBox: Half Checked
+- TextInput: Label, Text Value, Corner Radius
+- SwitchButton: Value
+- ProgressBar: Proportion, Show Number
+- Label: Is Hyperlink, Font Point Size
+- LabeledStaticBox: Corner Radius, Border Width, Border Color, Scale
+
+Each widget type uses dynamic_cast for safe detection."
+```
+
+---
+
+### Task 5: Wire plugins into MainFrame and CMakeLists
+
+**Files:**
+- Modify: `src/slic3r/GUI/MainFrame.cpp` (add include + registration call)
+- Modify: `src/slic3r/CMakeLists.txt` (add 4 source files)
+
+**Interfaces:**
+- Consumes: Tasks 1-4 (all plugins and registration helper)
+- Produces: Registered plugins available at runtime, buildable project
+
+- [ ] **Step 1: Add include in MainFrame.cpp**
+
+After the existing includes (around line 30, near the other Utils includes), add:
+
+```cpp
+#include "slic3r/Utils/wxInspectorPlugins/Registration.hpp"
+```
+
+- [ ] **Step 2: Add registration call in MainFrame constructor**
+
+After `SetupInspectorAccelerator(this);` (currently line ~303), add:
+
+```cpp
+RegisterOrcaInspectorPlugins();
+```
+
+- [ ] **Step 3: Add source files to CMakeLists.txt**
+
+Find the `SLIC3R_GUI_SOURCES` list in `src/slic3r/CMakeLists.txt`. After the existing `Utils/*.cpp` entries (around line 650-754), add:
+
+```cmake
+Utils/wxInspectorPlugins/DPIAwarePlugin.hpp
+Utils/wxInspectorPlugins/DPIAwarePlugin.cpp
+Utils/wxInspectorPlugins/CustomWidgetsPlugin.hpp
+Utils/wxInspectorPlugins/CustomWidgetsPlugin.cpp
+Utils/wxInspectorPlugins/Registration.hpp
+```
+
+(Note: Add all 5 files — 2 .hpp + 2 .cpp + 1 Registration.hpp. wxWidgets cmake needs headers listed too for the resource system.)
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/slic3r/GUI/MainFrame.cpp src/slic3r/CMakeLists.txt
+git commit -m "feat: wire wxInspector plugins into MainFrame and build
+
+- Call RegisterOrcaInspectorPlugins() after SetupInspectorAccelerator
+- Add all plugin source files to SLIC3R_GUI_SOURCES"
+```
+
+---
+
+### Task 6: Build and verify
+
+**Files:**
+- None modified (verification only)
+
+- [ ] **Step 1: Configure the build**
+
+```powershell
+$cmakePath = "D:\VisualStudio\2026\Community\Common7\IDE\CommonExtensions\Microsoft\CMake\CMake\bin\cmake.exe"
+& $cmakePath --build . --config Debug --target ALL_BUILD -- -m
+```
+
+Expected: Build succeeds with zero errors and zero warnings from our new files.
+
+- [ ] **Step 2: Fix any compilation errors**
+
+If the build fails:
+- Check that `#include` paths resolve (the `slic3r/GUI/…` relative paths use `src/` as the include root — verify this is set up in CMake via `include_directories`)
+- Check that `ButtonStyle` and `ButtonType` enums are visible (they're defined in `Button.hpp`)
+- Check that `StateColor` constructor from `wxColour` is valid (it has `StateColor(wxColour const&)`)
+- Check that `LabeledStaticBox::GetBorderColor()` returns by value (StateColor copy is fine)
+- On macOS: static box margin removal call needs `#ifdef __WXOSX__` guard
+
+- [ ] **Step 3: Launch OrcaSlicer and verify inspector**
+
+Launch the built OrcaSlicer, press Ctrl+Shift+I to open the inspector:
+1. Select the MainFrame in the tree — verify "DPI Scaling" category appears with Scale Factor, Prev Scale Factor, EM Unit, Normal Font, Force Rescale
+2. Select an Orca Button — verify "Orca Button" category appears
+3. Select an Orca CheckBox — verify "Orca CheckBox" category appears
+4. Edit a property value (e.g., Scale Factor) — verify the setter applies correctly
+5. Select a LabeledStaticBox — verify corner radius, border width, border color, scale appear
+
+- [ ] **Step 5: Commit (if fixes were needed) or mark complete**
+
+```bash
+git status
+```
+
+If clean: verification complete. If changes were made: `git add` and commit with fix message.
@@ -0,0 +1,102 @@
+# Move `wxInspectable` into `DPIAware` — Design Spec
+
+Date: 2026-07-23
+Branch: `dev/layout-inspector`
+
+## Overview
+
+Move the `wxInspector::wxInspectable` base class from individual leaf classes (`DPIDialog`, `MainFrame`) into the common `DPIAware<P>` template. This makes every DPIAware widget automatically visible in the inspector tree without requiring each subclass to opt in.
+
+## Motivation
+
+Currently, only `DPIDialog` and `MainFrame` explicitly inherit `wxInspectable`. `DPIFrame` (which `MainFrame` inherits from) does not — `MainFrame` adds it manually. This means:
+
+- Any `DPIAware<T>` widget that isn't `DPIDialog` or `MainFrame` is invisible in the inspector tree
+- `DPIFrame` subclasses (`BaseTransparentDPIFrame`, `ImageDPIFrame`, `ModelMallDialog`, `MediaFileFrame`, `SecondaryCheckDialog`, `PrintErrorDialog`, etc.) don't appear
+- Adding a new DPIAware widget type requires remembering to also inherit `wxInspectable`
+
+Moving `wxInspectable` to `DPIAware` fixes this for all current and future DPIAware widgets at once.
+
+## Design
+
+### Change 1: `GUI_Utils.hpp` — `DPIAware<P>`
+
+Add `wxInspector::wxInspectable` as a second base class, and call `SetupInspectorAccelerator(this)` in the constructor (after `this->CenterOnParent()`):
+
+```cpp
+// Before:
+template<class P> class DPIAware : public P
+
+// After:
+template<class P> class DPIAware : public P, public wxInspector::wxInspectable
+```
+
+Add in the constructor body (after `this->CenterOnParent()` at line 110):
+```cpp
+SetupInspectorAccelerator(this);
+```
+
+This gives every `DPIAware<T>` widget both inspectability and the Ctrl+Shift+I keyboard shortcut automatically. `#include <wx/inspector/inspector.h>` is already present in the file.
+
+### Change 2: `GUI_Utils.hpp` — `DPIDialog`
+
+Remove the now-redundant `wxInspector::wxInspectable` and the `SetupInspectorAccelerator(this)` call:
+
+```cpp
+// Before:
+class DPIDialog : public DPIAware<wxDialog>, public wxInspector::wxInspectable
+// ...
+    SetupInspectorAccelerator(this);
+
+// After:
+class DPIDialog : public DPIAware<wxDialog>
+// (SetupInspectorAccelerator call removed — now done in DPIAware constructor)
+```
+
+`DPIDialog` gets `wxInspectable` and the accelerator through `DPIAware<wxDialog>` now.
+
+### Change 3: `MainFrame.hpp` — `MainFrame`
+
+Remove the now-redundant `wxInspector::wxInspectable`:
+
+```cpp
+// Before:
+class MainFrame : public DPIFrame, public wxInspector::wxInspectable
+
+// After:
+class MainFrame : public DPIFrame
+```
+
+`MainFrame` gets `wxInspectable` through `DPIFrame` → `DPIAware<wxFrame>`.
+
+### Change 4: `MainFrame.cpp` — `MainFrame` constructor
+
+Remove the now-redundant `SetupInspectorAccelerator(this)` call (line 304). It will be called automatically by the `DPIAware` constructor.
+
+## Impact
+
+| Widget | Before | After |
+|--------|--------|-------|
+| `DPIDialog` subclasses (~80) | ✓ inspectable | ✓ inspectable (transitive) |
+| `MainFrame` | ✓ inspectable | ✓ inspectable (transitive) |
+| `DPIFrame` subclasses (8 others) | ✗ invisible | ✓ inspectable |
+| Future `DPIAware<T>` | ✗ invisible | ✓ inspectable |
+
+## Files Modified
+
+| File | Change |
+|------|--------|
+| `src/slic3r/GUI/GUI_Utils.hpp` | `DPIAware<P>` gains `wxInspector::wxInspectable` + `SetupInspectorAccelerator(this)` call; `DPIDialog` drops redundant `wxInspector::wxInspectable` and `SetupInspectorAccelerator(this)` |
+| `src/slic3r/GUI/MainFrame.hpp` | `MainFrame` drops redundant `wxInspector::wxInspectable` |
+| `src/slic3r/GUI/MainFrame.cpp` | Remove redundant `SetupInspectorAccelerator(this)` from MainFrame constructor |
+
+## Non-Goals
+
+- The `DPIAwarePlugin` detection logic (`dynamic_cast<DPIFrame*>` / `dynamic_cast<DPIDialog*>`) is unchanged
+- No new DPI properties — this is purely about tree visibility and accelerator setup
+
+## Risk Assessment
+
+- **Multiple inheritance**: `DPIAware<P>` already has a vtable (virtual destructor). Adding `wxInspectable` adds a second base but no additional data members. The `wxInspector::wxInspectable` class is expected to be a lightweight marker interface.
+- **Build**: No new includes needed; `<wx/inspector/inspector.h>` is already included in `GUI_Utils.hpp`.
+- **Cross-platform**: The change is standard C++ multiple inheritance — no platform-specific concerns.
@@ -0,0 +1,244 @@
+# wxInspector Plugins for OrcaSlicer Custom Controls — Design Spec
+
+Date: 2026-07-23
+Branch: `dev/layout-inspector`
+
+## Overview
+
+Create wxInspector plugins that expose OrcaSlicer's custom widget properties in the inspector's property grid. Without these plugins, the inspector shows only generic wxWidgets properties — missing all DPI-awareness data, custom styling, and Orca-specific control state.
+
+## Goals
+
+1. **DPIAware properties** — Inspect and update `scale_factor`, `prev_scale_factor`, `em_unit`, and `normal_font` on any DPIAware-derived widget
+2. **Custom widget properties** — Surface Orca-specific properties on `Button`, `CheckBox`, `TextInput`, `SwitchButton`, `ProgressBar`, `Label`, and `LabeledStaticBox`
+3. **Minimal source changes** — Only add trivial (one-line) getters/setters to existing classes; no architectural refactoring of Orca's widget hierarchy
+
+## Non-Goals
+
+- Custom inspector panels or AUI tabs (use the existing property grid and method invoker)
+- Python-plugin integration (this is C++ wxInspector, not Orca's Python plugin system)
+- Event logging customization (the built-in event logger already works)
+
+## Architecture
+
+### Two Plugins
+
+| Plugin | Class | Files |
+|--------|-------|-------|
+| DPIAware plugin | `DPIAwarePlugin` | `DPIAwarePlugin.hpp`, `DPIAwarePlugin.cpp` |
+| Custom widgets plugin | `CustomWidgetsPlugin` | `CustomWidgetsPlugin.hpp`, `CustomWidgetsPlugin.cpp` |
+| Registration helper | inline function | `Registration.hpp` |
+
+All files live under `src/slic3r/Utils/wxInspectorPlugins/`.
+
+### Plugin Detection Strategy
+
+**DPIAware plugin**: Uses `dynamic_cast<DPIFrame*>` and `dynamic_cast<DPIDialog*>` as detection gates. `DPIFrame` = `DPIAware<wxFrame>`, `DPIDialog` = `DPIAware<wxDialog>`. Since these are concrete typedefs, `dynamic_cast` works at runtime. This covers `MainFrame`, `SettingsDialog`, and all 8 calibration dialogs (which inherit `DPIDialog`).
+
+**Custom widgets plugin**: Gates broadly on `CLASSINFO(wxWindow)`, then uses per-type `dynamic_cast` inside `GetProperties` to check each Orca-specific type. Only matching types append properties.
+
+### Registration
+
+A single `RegisterOrcaInspectorPlugins()` inline function in `Registration.hpp` creates both plugins as function-local statics (matching the wxInspector built-in provider pattern) and registers them via `wxInspector::RegisterPlugin()`.
+
+Called once from `MainFrame::MainFrame()` after `SetupInspectorAccelerator(this)`.
+
+### Why Separate Plugins?
+
+- DPIAware is a C++ template concept (not a wxClassInfo-isKindOf check), so it needs its own detection logic
+- Custom widgets use standard wxClassInfo-based detection, matching the built-in provider pattern
+- Two focused files are easier to review and maintain than one monolithic plugin
+- Compile-time failure isolation: if a widget header changes, only one plugin breaks
+
+## DPIAware Plugin — Property Specification
+
+### Source Changes (GUI_Utils.hpp)
+
+Four one-liner methods added to the `DPIAware<P>` template class (public section):
+
+```cpp
+float scale_factor() const       { return m_scale_factor; }  // already exists
+float prev_scale_factor() const  { return m_prev_scale_factor; }  // already exists
+int   em_unit() const            { return m_em_unit; }  // already exists
+void  set_scale_factor(float v)      { m_scale_factor = v; }      // NEW
+void  set_prev_scale_factor(float v) { m_prev_scale_factor = v; } // NEW
+void  set_em_unit(int v)             { m_em_unit = v; }           // NEW
+bool  force_rescale() const          { return m_force_rescale; }  // NEW
+// m_normal_font getter already exists: normal_font()
+```
+
+### Detection
+
+```cpp
+bool CanProvideProperties(wxClassInfo* info) override {
+    // Gated in GetProperties via dynamic_cast on the window itself
+    return info->IsKindOf(CLASSINFO(wxWindow));
+}
+```
+
+In `GetProperties`:
+```cpp
+auto* win = obj.AsWindow();
+bool isDPI = dynamic_cast<DPIFrame*>(win) || dynamic_cast<DPIDialog*>(win);
+if (!isDPI) return props;
+```
+
+### Property Table (category: "DPI Scaling")
+
+| Name | Type | Editable | Getter | Setter |
+|------|------|----------|--------|--------|
+| Scale Factor | String (float) | Yes | `dpi->scale_factor()` | `dpi->set_scale_factor(v)` |
+| Prev Scale Factor | String (float) | Yes | `dpi->prev_scale_factor()` | `dpi->set_prev_scale_factor(v)` |
+| EM Unit | Integer | Yes | `dpi->em_unit()` | `dpi->set_em_unit(v)` |
+| Normal Font | ReadOnly | No | `dpi->normal_font().GetNativeFontInfoDesc()` | — |
+| Force Rescale | Boolean (ReadOnly) | No | `dpi->force_rescale()` | — |
+
+**Note on setters**: The setters simply store values. They do NOT trigger a widget rescale/layout. To see the effect of a changed scale factor, use the inspector's Methods panel to call `Layout()` or resize the window — which triggers the DPI_CHANGED event path naturally.
+
+## Custom Widgets Plugin — Property Specification
+
+All properties are appended to the built-in wxWindow properties. Each widget type is independently detected via `dynamic_cast`.
+
+### Detection gates (in `GetProperties`)
+
+```cpp
+auto* win = obj.AsWindow();
+if (auto* btn = dynamic_cast<Button*>(win))          { addButtonProperties(btn, props); }
+if (auto* cb  = dynamic_cast<CheckBox*>(win))         { addCheckBoxProperties(cb, props); }
+if (auto* ti  = dynamic_cast<TextInput*>(win))        { addTextInputProperties(ti, props); }
+if (auto* sb  = dynamic_cast<SwitchButton*>(win))     { addSwitchButtonProperties(sb, props); }
+if (auto* pb  = dynamic_cast<ProgressBar*>(win))      { addProgressBarProperties(pb, props); }
+if (auto* lbl = dynamic_cast<Label*>(win))            { addLabelProperties(lbl, props); }
+if (auto* lsb = dynamic_cast<LabeledStaticBox*>(win)) { addLabeledStaticBoxProperties(lsb, props); }
+```
+
+### Orca Button (`Button`) — category: "Orca Button"
+
+| Name | Type | Editable | Getter | Setter |
+|------|------|----------|--------|--------|
+| Button Style | Choice | Yes | enum→string | string→enum |
+| Button Type | Choice | Yes | enum→string | string→enum |
+| Selected | Boolean | Yes | `m_selected` (needs getter) | `SetSelected(v)` |
+| Active Icon | ReadOnly | No | icon name string | — |
+| Inactive Icon | ReadOnly | No | icon name string | — |
+
+Choices for Button Style: `Regular`, `Confirm`, `Alert`, `Disabled`
+Choices for Button Type: `Compact`, `Window`, `Choice`, `Parameter`, `Icon`, `Expanded`
+
+**Source changes needed**: Button's `m_selected` is private. Add one-liner getter:
+```cpp
+bool IsSelected() const { return m_selected; }
+```
+
+### Orca CheckBox (`CheckBox`) — category: "Orca CheckBox"
+
+| Name | Type | Editable | Getter | Setter |
+|------|------|----------|--------|--------|
+| Half Checked | Boolean | Yes | `m_half_checked` (needs getter) | `SetHalfChecked(v)` |
+
+**Source changes needed**: `m_half_checked` is private. Add one-liner getter:
+```cpp
+bool IsHalfChecked() const { return m_half_checked; }
+```
+
+### Orca TextInput (`TextInput`) — category: "Orca TextInput"
+
+| Name | Type | Editable | Getter | Setter |
+|------|------|----------|--------|--------|
+| Label | String | Yes | `GetLabel()` (inherited from wxWindow) | `SetLabel(v)` (exists) |
+| Text Value | String | Yes | `GetTextCtrl()->GetValue()` (GetTextCtrl is public) | `GetTextCtrl()->SetValue(v)` |
+| Corner Radius | Integer | Yes | `GetCornerRadius()` (NEW) | `SetCornerRadius(v)` (exists) |
+
+**Source changes needed**: Add one getter to `TextInput`:
+```cpp
+int GetCornerRadius() const { return static_cast<int>(radius); }
+```
+(`radius` is inherited from StaticBox. `SetCornerRadius(double)` already exists. `GetTextCtrl()` is already public.)
+
+### Orca SwitchButton (`SwitchButton`) — category: "Orca SwitchButton"
+
+| Name | Type | Editable | Getter | Setter |
+|------|------|----------|--------|--------|
+| Value | Boolean | Yes | existing getter | existing setter |
+
+### Orca ProgressBar (`ProgressBar`) — category: "Orca ProgressBar"
+
+| Name | Type | Editable | Getter | Setter |
+|------|------|----------|--------|--------|
+| Proportion | Float (0-1) | Yes | `pb->m_proportion` (public member) | `pb->m_proportion = v` |
+| Show Number | Boolean | Yes | `pb->m_shownumber` (public member) | `pb->m_shownumber = v` |
+
+**No source changes needed**: `m_proportion` and `m_shownumber` are already public members. `SetValue(int)` and `SetProgress(int)` already exist as public methods.
+
+### Orca Label (`Label`) — category: "Orca Label"
+
+| Name | Type | Editable | Getter | Setter |
+|------|------|----------|--------|--------|
+| Is Hyperlink | Boolean | No | existing flag check | — |
+| Font Size | ReadOnly | No | `GetFont().GetPointSize()` | — |
+
+### LabeledStaticBox — category: "LabeledStaticBox"
+
+| Name | Type | Editable | Getter | Setter |
+|------|------|----------|--------|--------|
+| Corner Radius | Integer | Yes | `GetCornerRadius()` (NEW) | `SetCornerRadius(v)` (exists) |
+| Border Width | Integer | Yes | `GetBorderWidth()` (NEW) | `SetBorderWidth(v)` (exists) |
+| Border Color | String (hex) | Yes | `GetBorderColor()` (NEW) | `SetBorderColor(v)` (exists) |
+| Scale | Float (ReadOnly) | No | `m_scale` (protected, needs getter) | — |
+
+**Source changes needed**: Four one-liner getters added to `LabeledStaticBox`:
+```cpp
+int   GetCornerRadius() const { return m_radius; }
+int   GetBorderWidth() const   { return m_border_width; }
+StateColor GetBorderColor() const { return border_color; }
+float GetScale() const         { return m_scale; }
+```
+
+## Files Modified (Existing Code)
+
+| File | Changes |
+|------|---------|
+| `src/slic3r/GUI/GUI_Utils.hpp` | +4 methods in `DPIAware<P>`: `set_scale_factor()`, `set_prev_scale_factor()`, `set_em_unit()`, `force_rescale()` |
+| `src/slic3r/GUI/Widgets/LabeledStaticBox.hpp` | +4 getter declarations: `GetCornerRadius()`, `GetBorderWidth()`, `GetBorderColor()`, `GetScale()` |
+| `src/slic3r/GUI/Widgets/LabeledStaticBox.cpp` | +4 getter implementations |
+| `src/slic3r/GUI/Widgets/Button.hpp` | +1 getter: `IsSelected()` |
+| `src/slic3r/GUI/Widgets/CheckBox.hpp` | +1 getter: `IsHalfChecked()` |
+| `src/slic3r/GUI/Widgets/TextInput.hpp` | +1 getter: `GetCornerRadius()` |
+| `src/slic3r/GUI/Widgets/ProgressBar.hpp` | None (public members are used directly) |
+| `src/slic3r/GUI/MainFrame.cpp` | +1 `#include`, +1 call to `RegisterOrcaInspectorPlugins()` |
+| `src/slic3r/CMakeLists.txt` | +4 entries in `SLIC3R_GUI_SOURCES` (the .cpp plugin files) |
+
+## Files Created
+
+```
+src/slic3r/Utils/wxInspectorPlugins/
+├── DPIAwarePlugin.hpp
+├── DPIAwarePlugin.cpp
+├── CustomWidgetsPlugin.hpp
+├── CustomWidgetsPlugin.cpp
+└── Registration.hpp
+```
+
+## Build & Linking
+
+The `wxInspector` dependency is already wired:
+- `deps/wxInspector/wxInspector.cmake` fetches and builds wxInspector
+- `src/CMakeLists.txt` lines 92-93 link `wxInspector::wxInspector` into `wxWidgets_LIBRARIES`
+- The plugin files only need `#include <wx/inspector/plugin.h>` and `#include <wx/inspector/inspector.h>` — both available from the installed dependency
+
+No new CMake dependencies needed. Only the new source files need listing in `SLIC3R_GUI_SOURCES`.
+
+## Error Handling & Edge Cases
+
+- **Stale pointers**: Plugin lambdas capture raw pointers, regenerated on every `GetProperties` call (matching wxInspector's built-in provider pattern). Pointers live only until the next tree selection.
+- **Widget destruction**: If a widget is destroyed while the inspector is showing its properties, `InspectableObject::IsValid()` returns false and properties are not displayed. The inspector won't show stale data.
+- **Invalid property values**: Setters use `sscanf` / `ToLong` with validation (matching built-in patterns). Bogus input is rejected — setter returns `false`, property grid shows error state.
+- **DPI drift**: Setting `scale_factor` without triggering rescale means displayed sizes don't match the new factor. This is acceptable — the inspector is a developer tool; operators know to call `Layout()` after making changes.
+- **Missing widget type**: If a `dynamic_cast` fails for all types, only built-in wxWindow properties are shown. No crash, no error — just reduced info.
+
+## Future Work (Out of Scope)
+
+- **StateColor visualization**: `StateColor` is a multi-value type (maps bitmask states to colors). A full solution would need a custom property editor (e.g., a table showing each state→color pair). Keep it simple for now.
+- **ScalableBitmap display**: Could show the bitmap as an inline thumbnail. Complex property editor work — deferred.
+- **More widget types**: `SwitchBoard`, `MultiSwitchButton`, `StepCtrl`, `FanControl`, `DropDown`, `ComboBox`, `AMS*` widgets could all benefit. Add as needed.
+- **Property refresh on tree selection**: Currently properties are static snapshots. A "refresh" button or auto-poll could keep values current for rapidly-changing widgets (progress bars, etc.). The built-in wxInspector already provides a tree-refresh button.
@@ -306,6 +306,12 @@ modules:
        sha256: c08bc65a81971c1dd5783182826503369466c7e67374d1646519adf05207b684
        dest: external-packages/python3

+      # wxInspector 1.0.0
+      - type: file
+        url: https://github.com/Noisyfox/wxInspector/archive/refs/tags/v1.0.0.zip
+        sha256: 0ba163956f2d468b19a91b96c5aba66ee9610843ea41dda628ea44cdafde7db7
+        dest: external-packages/wxInspector
+
      # ---------------------------------------------------------------
      # Fallback archives for deps normally provided by the GNOME SDK.
      # These are only used if find_package() fails to locate them.
@@ -88,6 +88,10 @@ if (SLIC3R_GUI)
    list(FILTER wxWidgets_LIBRARIES EXCLUDE REGEX OpenGL)

 #    list(REMOVE_ITEM wxWidgets_LIBRARIES oleacc)
+
+    find_package(wxInspector REQUIRED)
+    list(APPEND wxWidgets_LIBRARIES "wxInspector::wxInspector")
+
    message(STATUS "wx libs: ${wxWidgets_LIBRARIES}")

    add_subdirectory(slic3r)
@@ -5685,10 +5685,17 @@ LayerResult GCode::process_layer(
    for (const auto &layer_to_print : layers) {
        if (layer_to_print.object_layer) {
            const auto& regions = layer_to_print.object_layer->regions();
-            const bool  enable_overhang_speed = std::any_of(regions.begin(), regions.end(), [this](const LayerRegion* r) {
+            const bool has_extrusions = std::any_of(regions.begin(), regions.end(), [](const LayerRegion* r) {
+                return r->has_extrusions();
+            });
+            const bool enable_overhang_speed = std::any_of(regions.begin(), regions.end(), [this](const LayerRegion* r) {
                return r->has_extrusions() && r->region().config().enable_overhang_speed.get_at(get_nozzle_config_index(m_writer.filament()->id()));
            });
-            if (enable_overhang_speed) {
+            const bool enable_overhang_fan = m_enable_cooling_markers && has_extrusions &&
+                std::any_of(m_config.enable_overhang_bridge_fan.values.begin(),
+                            m_config.enable_overhang_bridge_fan.values.end(),
+                            [](unsigned char value) { return value != 0; });
+            if (enable_overhang_speed || enable_overhang_fan) {
                m_extrusion_quality_estimator.prepare_for_new_layer(layer_to_print.original_object,
                                                                    layer_to_print.object_layer);
            }
@@ -7527,7 +7534,10 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
    bool variable_speed = false;
    std::vector<ProcessedPoint> new_points {};

-    if (NOZZLE_CONFIG(enable_overhang_speed) && !this->on_first_layer() && !object_layer_over_raft() &&
+    const bool need_overhang_detection = NOZZLE_CONFIG(enable_overhang_speed) ||
+        (FILAMENT_CONFIG(enable_overhang_bridge_fan) && m_enable_cooling_markers);
+
+    if (need_overhang_detection && !this->on_first_layer() && !object_layer_over_raft() &&
        (is_bridge(path.role()) || is_perimeter(path.role()))) {
            bool is_external = is_external_perimeter(path.role());
            double ref_speed   = is_external ? NOZZLE_CONFIG(outer_wall_speed) : NOZZLE_CONFIG(inner_wall_speed);
@@ -7586,6 +7596,11 @@ std::string GCode::_extrude(const ExtrusionPath &path, std::string description,
            }
            variable_speed = std::any_of(new_points.begin(), new_points.end(),
                                         [speed](const ProcessedPoint &p) { return fabs(double(p.speed) - speed) > 1; }); // Ignore small speed variations (under 1mm/sec)
+            if (!NOZZLE_CONFIG(enable_overhang_speed) && FILAMENT_CONFIG(enable_overhang_bridge_fan) && m_enable_cooling_markers) {
+                for (ProcessedPoint &point : new_points)
+                    point.speed = speed;
+                variable_speed = new_points.size() > 1;
+            }
    }

    double F = speed * 60;  // convert mm/sec to mm/min
@@ -844,7 +844,10 @@ std::string CoolingBuffer::apply_layer_cooldown(
            ironing_fan_control = false; // ORCA: Add support for ironing fan speed control
            ironing_fan_speed = 0; // ORCA: Add support for ironing fan speed control
        }
-        if (fan_speed_new != m_fan_speed) {
+        // A tool change may keep the same configured base fan speed while the physical fan is
+        // still running at the previous filament's overhang speed. Restore the base speed before
+        // emitting G-code for the new tool in that case.
+        if (fan_speed_new != m_fan_speed || (immediately_apply && m_current_fan_speed != fan_speed_new)) {
            m_fan_speed = fan_speed_new;
            m_current_fan_speed = fan_speed_new;
            if (immediately_apply)
@@ -1040,8 +1043,10 @@ std::string CoolingBuffer::apply_layer_cooldown(
                new_gcode += GCodeWriter::set_fan(m_config.gcode_flavor, m_current_fan_speed, part_cooling_fan_min_pwm);
                fan_speed_change_requests[CoolingLine::TYPE_FORCE_RESUME_FAN] = false;
            }
-            else
+            else {
                new_gcode += GCodeWriter::set_fan(m_config.gcode_flavor, m_fan_speed, part_cooling_fan_min_pwm);
+                m_current_fan_speed = m_fan_speed;
+            }
            need_set_fan = false;
        }
        pos = line_end;
@@ -51,4 +51,9 @@
 // Enable extension of tool position imgui dialog to show actual speed profile
 #define ENABLE_ACTUAL_SPEED_DEBUG 1

+// Disable layout inspector for public release
+#if BBL_RELEASE_TO_PUBLIC
+#define WXINSPECTOR_DISABLE
+#endif
+
 #endif // _prusaslicer_technologies_h_
@@ -752,6 +752,11 @@ set(SLIC3R_GUI_SOURCES
    Utils/WxFontUtils.hpp
    Utils/FileTransferUtils.cpp
    Utils/FileTransferUtils.hpp
+    Utils/wxInspectorPlugins/DPIAwarePlugin.hpp
+    Utils/wxInspectorPlugins/DPIAwarePlugin.cpp
+    Utils/wxInspectorPlugins/CustomWidgetsPlugin.hpp
+    Utils/wxInspectorPlugins/CustomWidgetsPlugin.cpp
+    Utils/wxInspectorPlugins/Registration.hpp
 )

 add_subdirectory(GUI/DeviceCore)
@@ -13,6 +13,7 @@

 #include <boost/log/trivial.hpp>
 #include <boost/lexical_cast.hpp>
+#include <boost/format.hpp>

 #include "nlohmann/json.hpp"

@@ -96,6 +96,7 @@
 #include "../Utils/PresetUpdater.hpp"
 #include "../Utils/PrintHost.hpp"
 #include "../Utils/Process.hpp"
+#include "../Utils/wxInspectorPlugins/Registration.hpp"
 #include "../Utils/MacDarkMode.hpp"
 #include "../Utils/Http.hpp"
 #include "../Utils/InstanceID.hpp"
@@ -2835,6 +2836,9 @@ bool GUI_App::on_init_inner()

    ::Label::initSysFont();

+    // Register wxInspector plugins for Orca custom controls
+    RegisterOrcaInspectorPlugins();
+
    // Set initialization of image handlers before any UI actions - See GH issue #7469
    wxInitAllImageHandlers();
 #ifdef NDEBUG
@@ -3704,13 +3708,13 @@ bool GUI_App::on_init_network(bool try_backup)
            }
        } else {
            BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": on_init_network, load dll failed";
-            // A failed install can leave the config naming a build that never made it to
-            // disk (download_plugin() adopts the downloaded version up front so that
-            // install_plugin() can name the library after it). If the whitelisted latest
-            // is still installed, fall back to it instead of dropping the user into the
-            // re-download flow without networking.
+            // A failed install can leave the config naming a build that never made it to disk;
+            // fall back to the installed latest instead of dropping the user into the re-download
+            // flow. Only when the configured library is genuinely absent, though - a pinned series
+            // that is on disk but failed to load once must keep its pin, not be rewritten for good.
            std::string latest = get_latest_network_version();
-            if (config_version != latest && BBLNetworkPlugin::versioned_library_exists(latest)) {
+            if (config_version != latest && !BBLNetworkPlugin::versioned_library_exists(config_version)
+                && BBLNetworkPlugin::versioned_library_exists(latest)) {
                BOOST_LOG_TRIVIAL(warning) << __FUNCTION__ << ": falling back to installed " << latest;
                config_version = latest;
                app_config->set_network_plugin_version(latest);
@@ -3814,7 +3818,14 @@ bool GUI_App::on_init_network(bool try_backup)
            m_user_manager = new Slic3r::UserManager();
    }

-    if (should_load_networking_plugin && m_networking_compatible && !use_legacy_network_plugin()) {
+    // A version pinned to something other than the latest series is a deliberate choice, so it
+    // is exempt from the upgrade prompt the same way the legacy pin already is - otherwise the
+    // dialog reappears on every launch for as long as the pin is held.
+    const std::string pinned_version = app_config->get_network_plugin_version();
+    const bool pinned_to_older_series = !pinned_version.empty() &&
+        network_plugin_series(pinned_version) != network_plugin_series(get_latest_network_version());
+
+    if (should_load_networking_plugin && m_networking_compatible && !pinned_to_older_series) {
        app_config->clear_remind_network_update_later();

        if (has_network_update_available()) {
@@ -20,6 +20,7 @@
 #include <wx/settings.h>
 #include <wx/dataview.h>
 #include <wx/statbox.h>
+#include <wx/inspector/inspector.h>

 #include <chrono>
 #include "Event.hpp"
@@ -88,7 +89,7 @@ void update_dark_ui(wxWindow* window);

 extern std::deque<wxDialog*> dialogStack;

-template<class P> class DPIAware : public P
+template<class P> class DPIAware : public P, public wxInspector::wxInspectable
 {
 public:
    DPIAware(wxWindow *parent, wxWindowID id, const wxString &title, const wxPoint &pos=wxDefaultPosition,
@@ -107,6 +108,7 @@ public:
        this->SetFont(m_normal_font);
 #endif
        this->CenterOnParent();
+        SetupInspectorAccelerator(this);
 #ifdef _WIN32
        update_dark_ui(this);
 #endif
@@ -182,6 +184,11 @@ public:

    float   scale_factor() const        { return m_scale_factor; }
    float   prev_scale_factor() const   { return m_prev_scale_factor; }
+    // Only meant to be used by inspector, not public API
+    void    set_scale_factor(float v)      { m_scale_factor = v; }
+    void    set_prev_scale_factor(float v) { m_prev_scale_factor = v; }
+    void    set_em_unit(int v)             { m_em_unit = v; }
+    bool    force_rescale() const          { return m_force_rescale; }

    int     em_unit() const             { return m_em_unit; }
 //    int     font_size() const           { return m_font_size; }
@@ -739,7 +739,7 @@ DPIFrame(NULL, wxID_ANY, "", wxDefaultPosition, wxDefaultSize, BORDERLESS_FRAME_
            return;
        }

-        if (evt.CmdDown() && evt.GetKeyCode() == 'I') {
+        if (evt.CmdDown() && evt.GetKeyCode() == 'I' && !evt.ShiftDown()) {
            if (!can_add_models()) return;
            if (m_plater) { m_plater->add_file(); }
            return;
@@ -4552,6 +4552,9 @@ int PartPlateList::create_plate(bool adjust_position)
 		return -1;
 	int cols = compute_colum_count(new_index + 1);
 	int old_cols = compute_colum_count(new_index);
+	// Orca: Rebuild plate membership before moving instances during a grid reflow.
+	if (adjust_position && old_cols != cols)
+		reload_all_objects();

 	origin = compute_origin(new_index, cols);
 	plate = new PartPlate(this, origin, m_plate_width, m_plate_depth, m_plate_height, m_plater, m_model, true, printer_technology);
@@ -5041,6 +5044,9 @@ int PartPlateList::move_plate_to_index(int old_index, int new_index)
 		return -1;
 	}

+	// Orca: Rebuild plate membership before moving the plates.
+	reload_all_objects();
+
 	if (old_index < new_index)
 	{
 		delta = 1;
@@ -8000,7 +8000,9 @@ void Tab::update_extruder_variants(int extruder_id, bool reload)
        m_actual_nozzle_volumes.resize(extruder_nums, NozzleVolumeType::nvtStandard);
        for (int i = 0; i < extruder_nums; i++) m_actual_nozzle_volumes[i] = (NozzleVolumeType)nozzle_volumes->values[i];

-        if (extruder_nums == 2) {
+        // Orca: a non-Bambu dual-nozzle printer has two extruders but a single variant column, so
+        // the nozzle switch and sync button have nothing to act on. Only enable with real variants.
+        if (extruder_nums == 2 && m_preset_bundle->support_different_extruders()) {
            auto options = generate_extruder_options();
            m_extruder_switch->SetOptions(options);

@@ -77,6 +77,11 @@ public:

    void SetSelected(bool selected = true) { m_selected = selected; }

+    // Only meant to be used by inspector, not public API
+    ButtonStyle GetStyle() const { return m_style; }
+    ButtonType  GetType() const  { return m_type; }
+    bool IsSelected() const      { return m_selected; }
+
    bool Enable(bool enable = true) override;
    void EnableTooltipEvenDisabled();// The tip will be shown even if the button is disabled

@@ -15,6 +15,9 @@ public:

 	void SetHalfChecked(bool value = true);

+	// Only meant to be used by inspector, not public API
+	bool IsHalfChecked() const { return m_half_checked; }
+
 	void Rescale();

 #ifdef __WXOSX__
@@ -46,6 +46,12 @@ public:

    bool Enable(bool enable) override;

+    // Only meant to be used by inspector, not public API
+    int        GetCornerRadius() const { return m_radius; }
+    int        GetBorderWidth() const  { return m_border_width; }
+    StateColor GetBorderColor() const  { return border_color; }
+    float      GetScale() const        { return m_scale; }
+
 private:
    void PickDC(wxDC& dc);

@@ -43,6 +43,9 @@ public:

    void SetCornerRadius(double radius);

+    // Only meant to be used by inspector, not public API
+    int GetCornerRadius() const { return static_cast<int>(radius); }
+
    void SetLabel(const wxString& label);

    void SetStaticTips(const wxString& tips, const wxBitmap& bitmap);
@@ -602,6 +602,12 @@ WXLRESULT wxMediaCtrl2::MSWWindowProc(WXUINT   nMsg,
                                   WXWPARAM wParam,
                                   WXLPARAM lParam)
 {
+    // The stream source sends WM_USER+1000 with a synchronous SendMessage from its own threads,
+    // so this runs re-entrantly on the UI thread at whatever message-retrieval point the player
+    // happens to be in - often nested inside an Orca log statement. Never BOOST_LOG_TRIVIAL here:
+    // boost::log is not re-entrant on one thread, and doing so corrupted its per-thread record
+    // state, crashing later in unrelated places (the player, the log filter, a plug-in heap free).
+    // Post the string out (as the stat branch does) and log it on a clean stack instead.
    if (nMsg == WM_USER + 1000) {
        wxString msg((wchar_t const *) lParam);
        if (wParam == 1) {
@@ -619,7 +625,6 @@ WXLRESULT wxMediaCtrl2::MSWWindowProc(WXUINT   nMsg,
                wxPostEvent(this, evt);
            }
        }
-        BOOST_LOG_TRIVIAL(trace) << msg.ToUTF8().data();
        return 0;
    }
    return wxMediaCtrl::MSWWindowProc(nMsg, wParam, lParam);
@@ -17,6 +17,20 @@ namespace Slic3r {

 #define BAMBU_SOURCE_LIBRARY "BambuSource"

+namespace {
+
+// Named in the load log: the bound generation is what ties a crash report to an ABI choice.
+// The label is the whitelist row's series, so it can never drift from the dispatch table.
+const char* network_abi_name(NetworkAbi abi)
+{
+    for (size_t i = 0; i < AVAILABLE_NETWORK_VERSIONS_COUNT; ++i)
+        if (AVAILABLE_NETWORK_VERSIONS[i].abi == abi)
+            return AVAILABLE_NETWORK_VERSIONS[i].version;
+    return "unsupported";
+}
+
+} // namespace
+
 // ============================================================================
 // Singleton Implementation
 // ============================================================================
@@ -162,19 +176,20 @@ int BBLNetworkPlugin::initialize(bool using_backup, const std::string& version)
    // Load all function pointers
    load_all_function_pointers();

-    // Sync legacy network flag from loaded plugin
-    m_use_legacy_network = is_legacy_version(version);
+    // Key the generation on the library that actually loaded, not the version asked for:
+    // resolve_library_path() serves any same-series build. m_get_version is read directly, not
+    // via get_version(), which would substitute the "00.00.00.00" sentinel and pick no generation.
+    const std::string loaded_version = m_get_version ? m_get_version() : std::string();
+    m_network_abi = network_plugin_abi(loaded_version.empty() ? version : loaded_version);

-    std::string loaded_version;
-    if (m_get_version) {
-        loaded_version = m_get_version();
-        if (!loaded_version.empty()) {
-            m_use_legacy_network = is_legacy_version(loaded_version);
-        }
+    // A library reporting a series this build has no ABI for stays loaded but uncallable -
+    // check_networking_version() then reports it as incompatible and offers the update flow.
+    if (m_network_abi == NetworkAbi::Unsupported) {
+        BOOST_LOG_TRIVIAL(warning) << "BBLNetworkPlugin::initialize: no ABI for version "
+            << (loaded_version.empty() ? version : loaded_version) << ", plug-in calls are disabled";
    }

-    BOOST_LOG_TRIVIAL(info) << "BBLNetworkPlugin::initialize: legacy_mode="
-        << (m_use_legacy_network ? "true" : "false")
+    BOOST_LOG_TRIVIAL(info) << "BBLNetworkPlugin::initialize: abi=" << network_abi_name(m_network_abi)
        << ", library=" << library
        << ", version=" << (loaded_version.empty() ? "unknown" : loaded_version)
        << ", send_message=" << (m_send_message ? "loaded" : "null")
@@ -217,7 +232,9 @@ int BBLNetworkPlugin::unload()

    clear_all_function_pointers();

-    m_use_legacy_network = false;
+    // Safe to reset only because every pointer was nulled just above and every dispatcher is
+    // guarded on a non-null pointer, so no stale generation is reachable.
+    m_network_abi = NetworkAbi::Unsupported;

    return 0;
 }
@@ -520,7 +537,7 @@ void BBLNetworkPlugin::set_load_error(const std::string& message,
 }

 // ============================================================================
-// Legacy Helper
+// ABI Conversion Helpers
 // ============================================================================

 PrintParams_Legacy BBLNetworkPlugin::as_legacy(PrintParams& param)
@@ -564,6 +581,57 @@ PrintParams_Legacy BBLNetworkPlugin::as_legacy(PrintParams& param)
    return l;
 }

+// Every PrintParams field except the four the 02.08.01 series added
+// (task_timelapse_use_internal, extruder_cali_manual_mode, svc_context, slicer_uid).
+PrintParams_0203 BBLNetworkPlugin::as_0203(PrintParams& param)
+{
+    PrintParams_0203 p;
+
+    p.dev_id                 = std::move(param.dev_id);
+    p.task_name              = std::move(param.task_name);
+    p.project_name           = std::move(param.project_name);
+    p.preset_name            = std::move(param.preset_name);
+    p.filename               = std::move(param.filename);
+    p.config_filename        = std::move(param.config_filename);
+    p.plate_index            = param.plate_index;
+    p.ftp_folder             = std::move(param.ftp_folder);
+    p.ftp_file               = std::move(param.ftp_file);
+    p.ftp_file_md5           = std::move(param.ftp_file_md5);
+    p.nozzle_mapping         = std::move(param.nozzle_mapping);
+    p.ams_mapping            = std::move(param.ams_mapping);
+    p.ams_mapping2           = std::move(param.ams_mapping2);
+    p.ams_mapping_info       = std::move(param.ams_mapping_info);
+    p.nozzles_info           = std::move(param.nozzles_info);
+    p.connection_type        = std::move(param.connection_type);
+    p.comments               = std::move(param.comments);
+    p.origin_profile_id      = param.origin_profile_id;
+    p.stl_design_id          = param.stl_design_id;
+    p.origin_model_id        = std::move(param.origin_model_id);
+    p.print_type             = std::move(param.print_type);
+    p.dst_file               = std::move(param.dst_file);
+    p.dev_name               = std::move(param.dev_name);
+    p.dev_ip                 = std::move(param.dev_ip);
+    p.use_ssl_for_ftp        = param.use_ssl_for_ftp;
+    p.use_ssl_for_mqtt       = param.use_ssl_for_mqtt;
+    p.username               = std::move(param.username);
+    p.password               = std::move(param.password);
+    p.task_bed_leveling      = param.task_bed_leveling;
+    p.task_flow_cali         = param.task_flow_cali;
+    p.task_vibration_cali    = param.task_vibration_cali;
+    p.task_layer_inspect     = param.task_layer_inspect;
+    p.task_record_timelapse  = param.task_record_timelapse;
+    p.task_use_ams           = param.task_use_ams;
+    p.task_bed_type          = std::move(param.task_bed_type);
+    p.extra_options          = std::move(param.extra_options);
+    p.auto_bed_leveling      = param.auto_bed_leveling;
+    p.auto_flow_cali         = param.auto_flow_cali;
+    p.auto_offset_cali       = param.auto_offset_cali;
+    p.task_ext_change_assist = param.task_ext_change_assist;
+    p.try_emmc_print         = param.try_emmc_print;
+
+    return p;
+}
+
 // ============================================================================
 // Function Pointer Loading
 // ============================================================================
@@ -669,7 +737,8 @@ void BBLNetworkPlugin::load_all_function_pointers()
    m_get_mw_user_preference = reinterpret_cast<func_get_mw_user_preference>(get_function("bambu_network_get_mw_user_preference"));
    m_get_mw_user_4ulist = reinterpret_cast<func_get_mw_user_4ulist>(get_function("bambu_network_get_mw_user_4ulist"));

-    // Added by the 02.08.01.52 plugin ABI; resolve to null on older plugins so callers no-op.
+    // Bound late; anything a generation does not export resolves to null so callers no-op.
+    // See the typedefs for which generation introduced each of these.
    m_set_on_user_login_fn = reinterpret_cast<func_set_on_user_login_fn>(get_function("bambu_network_set_on_user_login_fn"));
    m_get_studio_info_url = reinterpret_cast<func_get_studio_info_url>(get_function("bambu_network_get_studio_info_url"));
    m_report_consent = reinterpret_cast<func_report_consent>(get_function("bambu_network_report_consent"));
@@ -119,7 +119,7 @@ typedef int (*func_get_model_mall_rating_result)(void *agent, int job_id, std::s
 typedef int (*func_get_mw_user_preference)(void *agent, std::function<void(std::string)> callback);
 typedef int (*func_get_mw_user_4ulist)(void *agent, int seed, int limit, std::function<void(std::string)> callback);

-// Legacy function pointer types (for older DLL versions)
+// Legacy function pointer types (for the 01.10.01 DLL)
 typedef int (*func_start_print_legacy)(void *agent, PrintParams_Legacy params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn);
 typedef int (*func_start_local_print_with_record_legacy)(void *agent, PrintParams_Legacy params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn);
 typedef int (*func_start_send_gcode_to_sdcard_legacy)(void *agent, PrintParams_Legacy params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn);
@@ -128,10 +128,25 @@ typedef int (*func_start_sdcard_print_legacy)(void* agent, PrintParams_Legacy pa
 typedef int (*func_send_message_legacy)(void* agent, std::string dev_id, std::string json_str, int qos);
 typedef int (*func_send_message_to_printer_legacy)(void* agent, std::string dev_id, std::string json_str, int qos);

-// Added by the 02.08.01.52 plugin ABI (null on older plugins).
+// 02.03.00 function pointer types. Only PrintParams differs from the current ABI; send_message
+// and send_message_to_printer already take the flag argument in this series.
+typedef int (*func_start_print_0203)(void *agent, PrintParams_0203 params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn);
+typedef int (*func_start_local_print_with_record_0203)(void *agent, PrintParams_0203 params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn);
+typedef int (*func_start_send_gcode_to_sdcard_0203)(void *agent, PrintParams_0203 params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn);
+typedef int (*func_start_local_print_0203)(void *agent, PrintParams_0203 params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
+typedef int (*func_start_sdcard_print_0203)(void* agent, PrintParams_0203 params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn);
+
+// bind() gained dev_model in 02.08.01; the legacy and 02.03.00 series share the older form.
+typedef int (*func_bind_pre0208)(void *agent, std::string dev_ip, std::string dev_id, std::string sec_link, std::string timezone, bool improved, OnUpdateStatusFn update_fn);
+
+// Exported by every supported generation, but only bound here.
 typedef int (*func_set_on_user_login_fn)(void *agent, OnUserLoginFn fn);
 typedef std::string (*func_get_studio_info_url)(void *agent);
+
+// Present since 02.03.00, null on the legacy plugin.
 typedef int (*func_report_consent)(void *agent, std::string expand);
+
+// Added by the 02.08.01.52 plugin ABI (null on older plugins).
 typedef int (*func_get_camera_url_for_golive)(void *agent, std::string dev_id, std::string sdev_id, std::function<void(std::string)> callback);
 typedef int (*func_get_hms_snapshot)(void *agent, std::string& dev_id, std::string& file_name, std::function<void(std::string, int)> callback);
 typedef int (*func_get_filament_spools)(void *agent, FilamentQueryParams params, std::string* http_body);
@@ -279,12 +294,13 @@ public:
                        const std::string& attempted_path);

    // ========================================================================
-    // Legacy Network Flag
+    // Plug-in ABI Generation
    // ========================================================================

    static bool is_legacy_version(const std::string& version) { return version == BAMBU_NETWORK_AGENT_VERSION_LEGACY; }
-    bool use_legacy_network() const { return m_use_legacy_network; }
-    void set_use_legacy_network(bool legacy) { m_use_legacy_network = legacy; }
+    // The generation the loaded library speaks - what every call must dispatch on.
+    NetworkAbi network_abi() const { return m_network_abi; }
+    bool use_legacy_network() const { return m_network_abi == NetworkAbi::Legacy; }

    // ========================================================================
    // Function Pointer Accessors
@@ -401,10 +417,12 @@ public:
    func_sync_ams_filaments get_sync_ams_filaments() const { return m_sync_ams_filaments; }

    // ========================================================================
-    // Legacy Helper
+    // ABI Conversion Helpers
    // ========================================================================

+    // Both move out of `param`, so convert only inside the branch that will actually run.
    static PrintParams_Legacy as_legacy(PrintParams& param);
+    static PrintParams_0203 as_0203(PrintParams& param);

 private:
    // Singleton instance pointer (heap-allocated for explicit lifetime control)
@@ -431,8 +449,8 @@ private:
    // Load error state
    NetworkLibraryLoadError m_load_error;

-    // Legacy network compatibility flag
-    bool m_use_legacy_network{false};
+    // ABI generation of the currently loaded library
+    NetworkAbi m_network_abi{NetworkAbi::Unsupported};

    // Function pointers
    func_check_debug_consistent m_check_debug_consistent{nullptr};
@@ -26,11 +26,19 @@ int BBLPrinterAgent::send_message(std::string dev_id, std::string json_str, int
    auto agent = plugin.get_agent();
    auto func = plugin.get_send_message();
    if (func && agent) {
-        if (plugin.use_legacy_network()) {
+        // Only the legacy plug-in lacks `flag`; 02.03.00 already takes it, and routing that
+        // series through the legacy form would silently drop MessageFlag sign/encrypt.
+        switch (plugin.network_abi()) {
+        case NetworkAbi::Legacy: {
            auto legacy_func = reinterpret_cast<func_send_message_legacy>(func);
-            return legacy_func(agent, dev_id, json_str, qos);
+            return legacy_func(agent, std::move(dev_id), std::move(json_str), qos);
+        }
+        case NetworkAbi::V0203:
+        case NetworkAbi::Current:
+            return func(agent, std::move(dev_id), std::move(json_str), qos, flag);
+        default:
+            return -1;
        }
-        return func(agent, dev_id, json_str, qos, flag);
    }
    return -1;
 }
@@ -63,11 +71,17 @@ int BBLPrinterAgent::send_message_to_printer(std::string dev_id, std::string jso
    auto agent = plugin.get_agent();
    auto func = plugin.get_send_message_to_printer();
    if (func && agent) {
-        if (plugin.use_legacy_network()) {
+        switch (plugin.network_abi()) {
+        case NetworkAbi::Legacy: {
            auto legacy_func = reinterpret_cast<func_send_message_to_printer_legacy>(func);
-            return legacy_func(agent, dev_id, json_str, qos);
+            return legacy_func(agent, std::move(dev_id), std::move(json_str), qos);
+        }
+        case NetworkAbi::V0203:
+        case NetworkAbi::Current:
+            return func(agent, std::move(dev_id), std::move(json_str), qos, flag);
+        default:
+            return -1;
        }
-        return func(agent, dev_id, json_str, qos, flag);
    }
    return -1;
 }
@@ -144,7 +158,19 @@ int BBLPrinterAgent::bind(std::string dev_ip, std::string dev_id, std::string de
    auto agent = plugin.get_agent();
    auto func = plugin.get_bind();
    if (func && agent) {
-        return func(agent, dev_ip, dev_id, dev_model, sec_link, timezone, improved, update_fn);
+        // dev_model was added in 02.08.01. Passing it to a plug-in that takes the 7-argument
+        // form shifts every following argument, so the older generations get the older call.
+        switch (plugin.network_abi()) {
+        case NetworkAbi::Legacy:
+        case NetworkAbi::V0203: {
+            auto older_func = reinterpret_cast<func_bind_pre0208>(func);
+            return older_func(agent, dev_ip, dev_id, sec_link, timezone, improved, update_fn);
+        }
+        case NetworkAbi::Current:
+            return func(agent, dev_ip, dev_id, dev_model, sec_link, timezone, improved, update_fn);
+        default:
+            return -1;
+        }
    }
    return -1;
 }
@@ -281,84 +307,62 @@ AgentInfo BBLPrinterAgent::get_agent_info_static()
 // Print Job Operations
 // ============================================================================

-int BBLPrinterAgent::start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
+namespace {
+
+// Shared dispatcher for the start_* operations, whose params layout differs per generation.
+// The per-generation typedefs are template arguments so a swapped pair fails to compile
+// (each arm's converted params must match the casted signature). Each arm converts and calls
+// in one step: as_legacy()/as_0203() move out of `params` and their prvalue result lands in
+// the by-value ABI argument without another copy; the Current arm moves `params` outright.
+template <typename LegacyFn, typename Fn0203, typename CurrentFn, typename... CallbackFns>
+int dispatch_start(CurrentFn func, PrintParams& params, const CallbackFns&... callbacks)
 {
    auto& plugin = BBLNetworkPlugin::instance();
    auto agent = plugin.get_agent();
-    auto func = plugin.get_start_print();
-    if (func && agent) {
-        if (plugin.use_legacy_network()) {
-            auto legacy_func = reinterpret_cast<func_start_print_legacy>(func);
-            auto legacy_params = BBLNetworkPlugin::as_legacy(params);
-            return legacy_func(agent, legacy_params, update_fn, cancel_fn, wait_fn);
-        }
-        return func(agent, params, update_fn, cancel_fn, wait_fn);
+    if (!func || !agent)
+        return -1;
+    switch (plugin.network_abi()) {
+    case NetworkAbi::Legacy:
+        return reinterpret_cast<LegacyFn>(func)(agent, BBLNetworkPlugin::as_legacy(params), callbacks...);
+    case NetworkAbi::V0203:
+        return reinterpret_cast<Fn0203>(func)(agent, BBLNetworkPlugin::as_0203(params), callbacks...);
+    case NetworkAbi::Current:
+        return func(agent, std::move(params), callbacks...);
+    default:
+        return -1;
    }
-    return -1;
+}
+
+} // namespace
+
+int BBLPrinterAgent::start_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
+{
+    return dispatch_start<func_start_print_legacy, func_start_print_0203>(
+        BBLNetworkPlugin::instance().get_start_print(), params, update_fn, cancel_fn, wait_fn);
 }

 int BBLPrinterAgent::start_local_print_with_record(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
 {
-    auto& plugin = BBLNetworkPlugin::instance();
-    auto agent = plugin.get_agent();
-    auto func = plugin.get_start_local_print_with_record();
-    if (func && agent) {
-        if (plugin.use_legacy_network()) {
-            auto legacy_func = reinterpret_cast<func_start_local_print_with_record_legacy>(func);
-            auto legacy_params = BBLNetworkPlugin::as_legacy(params);
-            return legacy_func(agent, legacy_params, update_fn, cancel_fn, wait_fn);
-        }
-        return func(agent, params, update_fn, cancel_fn, wait_fn);
-    }
-    return -1;
+    return dispatch_start<func_start_local_print_with_record_legacy, func_start_local_print_with_record_0203>(
+        BBLNetworkPlugin::instance().get_start_local_print_with_record(), params, update_fn, cancel_fn, wait_fn);
 }

 int BBLPrinterAgent::start_send_gcode_to_sdcard(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn, OnWaitFn wait_fn)
 {
-    auto& plugin = BBLNetworkPlugin::instance();
-    auto agent = plugin.get_agent();
-    auto func = plugin.get_start_send_gcode_to_sdcard();
-    if (func && agent) {
-        if (plugin.use_legacy_network()) {
-            auto legacy_func = reinterpret_cast<func_start_send_gcode_to_sdcard_legacy>(func);
-            auto legacy_params = BBLNetworkPlugin::as_legacy(params);
-            return legacy_func(agent, legacy_params, update_fn, cancel_fn, wait_fn);
-        }
-        return func(agent, params, update_fn, cancel_fn, wait_fn);
-    }
-    return -1;
+    return dispatch_start<func_start_send_gcode_to_sdcard_legacy, func_start_send_gcode_to_sdcard_0203>(
+        BBLNetworkPlugin::instance().get_start_send_gcode_to_sdcard(), params, update_fn, cancel_fn, wait_fn);
 }

 int BBLPrinterAgent::start_local_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
 {
-    auto& plugin = BBLNetworkPlugin::instance();
-    auto agent = plugin.get_agent();
-    auto func = plugin.get_start_local_print();
-    if (func && agent) {
-        if (plugin.use_legacy_network()) {
-            auto legacy_func = reinterpret_cast<func_start_local_print_legacy>(func);
-            auto legacy_params = BBLNetworkPlugin::as_legacy(params);
-            return legacy_func(agent, legacy_params, update_fn, cancel_fn);
-        }
-        return func(agent, params, update_fn, cancel_fn);
-    }
-    return -1;
+    return dispatch_start<func_start_local_print_legacy, func_start_local_print_0203>(
+        BBLNetworkPlugin::instance().get_start_local_print(), params, update_fn, cancel_fn);
 }

 int BBLPrinterAgent::start_sdcard_print(PrintParams params, OnUpdateStatusFn update_fn, WasCancelledFn cancel_fn)
 {
-    auto& plugin = BBLNetworkPlugin::instance();
-    auto agent = plugin.get_agent();
-    auto func = plugin.get_start_sdcard_print();
-    if (func && agent) {
-        if (plugin.use_legacy_network()) {
-            auto legacy_func = reinterpret_cast<func_start_sdcard_print_legacy>(func);
-            auto legacy_params = BBLNetworkPlugin::as_legacy(params);
-            return legacy_func(agent, legacy_params, update_fn, cancel_fn);
-        }
-        return func(agent, params, update_fn, cancel_fn);
-    }
-    return -1;
+    return dispatch_start<func_start_sdcard_print_legacy, func_start_sdcard_print_0203>(
+        BBLNetworkPlugin::instance().get_start_sdcard_print(), params, update_fn, cancel_fn);
 }

 // ============================================================================
@@ -230,6 +230,59 @@ struct PrintParams_Legacy {
    std::string     extra_options;
 };

+/* print job, as the 02.03.00 series expects it. The 02.08.01 series inserted
+   task_timelapse_use_internal, extruder_cali_manual_mode, svc_context and slicer_uid into
+   PrintParams; two of them sit mid-struct, so an older plug-in misreads every field from
+   task_use_ams onwards if handed the current layout. Rebuild it with as_0203() instead. */
+struct PrintParams_0203 {
+    /* basic info */
+    std::string     dev_id;
+    std::string     task_name;
+    std::string     project_name;
+    std::string     preset_name;
+    std::string     filename;
+    std::string     config_filename;
+    int             plate_index;
+    std::string     ftp_folder;
+    std::string     ftp_file;
+    std::string     ftp_file_md5;
+    std::string     nozzle_mapping;
+    std::string     ams_mapping;
+    std::string     ams_mapping2;
+    std::string     ams_mapping_info;
+    std::string     nozzles_info;
+    std::string     connection_type;
+    std::string     comments;
+    int             origin_profile_id = 0;
+    int             stl_design_id = 0;
+    std::string     origin_model_id;
+    std::string     print_type;
+    std::string     dst_file;
+    std::string     dev_name;
+
+    /* access options */
+    std::string     dev_ip;
+    bool            use_ssl_for_ftp;
+    bool            use_ssl_for_mqtt;
+    std::string     username;
+    std::string     password;
+
+    /*user options */
+    bool            task_bed_leveling;      /* bed leveling of task */
+    bool            task_flow_cali;         /* flow calibration of task */
+    bool            task_vibration_cali;    /* vibration calibration of task */
+    bool            task_layer_inspect;     /* first layer inspection of task */
+    bool            task_record_timelapse;  /* record timelapse of task */
+    bool            task_use_ams;
+    std::string     task_bed_type;
+    std::string     extra_options;
+    int             auto_bed_leveling{ 0 };
+    int             auto_flow_cali{ 0 };
+    int             auto_offset_cali{ 0 };
+    bool            task_ext_change_assist;
+    bool            try_emmc_print;
+};
+
 /* print job*/
 struct PrintParams {
    /* basic info */
@@ -351,21 +404,34 @@ struct CertificateInformation {
    std::string     serial_number;
 };

+// The plug-in ABI generation a library speaks. Generations differ in by-value struct layouts and
+// function signatures, so a call must go through the matching typedefs (see BBLPrinterAgent) -
+// the wrong one corrupts the stack rather than failing cleanly.
+enum class NetworkAbi {
+    Unsupported, // no generation in this build can call it - never dispatch through it
+    Legacy,      // 01.10.01: PrintParams_Legacy; send_message/send_message_to_printer take no flag
+    V0203,       // 02.03.00: PrintParams_0203; bind takes no dev_model
+    Current,     // 02.08.01: the layouts and signatures this build declares directly
+};
+
 struct NetworkLibraryVersion {
    const char* version;
    const char* display_name;
    const char* url_override;
    bool is_latest;
    const char* warning;
+    NetworkAbi abi;
 };

-// Only the latest series and the legacy build are offered/loadable: the host binds the
-// modern ABI (by-value struct layouts, function signatures) of exactly one series, plus
-// a dedicated shim for the legacy build. Older 02.0x series expect different layouts
-// and must not be loaded - see is_supported_network_version().
+// Every row names the generation that can call it, so a series can never be offered without a
+// host-side ABI for it. Series with no generation - 02.01.01, 02.00.02 and older - must stay out;
+// is_supported_network_version() is the gate that keeps them from loading.
 static const NetworkLibraryVersion AVAILABLE_NETWORK_VERSIONS[] = {
-    {"02.08.01", "02.08.01", nullptr, true, nullptr},
-    {BAMBU_NETWORK_AGENT_VERSION_LEGACY, BAMBU_NETWORK_AGENT_VERSION_LEGACY " (legacy)", nullptr, false, nullptr},
+    {"02.08.01", "02.08.01", nullptr, true, nullptr, NetworkAbi::Current},
+    {"02.03.00", "02.03.00", nullptr, false,
+     "An older plug-in series. Features that need newer plug-in support, such as print-failure "
+     "snapshots in the device error dialog, are unavailable.", NetworkAbi::V0203},
+    {BAMBU_NETWORK_AGENT_VERSION_LEGACY, BAMBU_NETWORK_AGENT_VERSION_LEGACY " (legacy)", nullptr, false, nullptr, NetworkAbi::Legacy},
 };

 static const size_t AVAILABLE_NETWORK_VERSIONS_COUNT = sizeof(AVAILABLE_NETWORK_VERSIONS) / sizeof(AVAILABLE_NETWORK_VERSIONS[0]);
@@ -378,23 +444,43 @@ inline const char* get_latest_network_version() {
    return AVAILABLE_NETWORK_VERSIONS[0].version;
 }

-// True when the version can be loaded through the ABI this build was compiled against:
-// an exact whitelist entry, or a build from the same AA.BB.CC series as a non-legacy
-// whitelist entry (the plugin ABI is stable within a series, and the OTA sync only ever
-// installs same-series updates). Anything else - in particular older 02.0x series a
-// previous Orca release whitelisted - expects different by-value struct layouts and
-// function signatures and must not be loaded.
-inline bool is_supported_network_version(const std::string& version) {
+// The AA.BB.CC series of a modern version string - the plug-in's stored identity. The 4th
+// component is only which build of the series happens to be installed and is read live from
+// the loaded plug-in for display. Legacy keeps its exact string (the shim matches exactly).
+inline std::string network_plugin_series(const std::string& version) {
+    if (version.empty() || version == BAMBU_NETWORK_AGENT_VERSION_LEGACY)
+        return version;
+    return version.size() >= 8 ? version.substr(0, 8) : version;
+}
+
+// Index of the whitelist entry that can load this version: an exact match, or a build of the same
+// AA.BB.CC series as a non-legacy entry (the ABI is stable within a series, and the OTA sync only
+// installs same-series updates). Legacy matches exactly only - a sibling build of that series
+// would come through the modern layout. AVAILABLE_NETWORK_VERSIONS_COUNT when nothing matches.
+inline size_t find_network_version_index(const std::string& version) {
+    const std::string series = network_plugin_series(version);
    for (size_t i = 0; i < AVAILABLE_NETWORK_VERSIONS_COUNT; ++i) {
        const std::string base = AVAILABLE_NETWORK_VERSIONS[i].version;
        if (version == base)
-            return true;
+            return i;
        if (base == BAMBU_NETWORK_AGENT_VERSION_LEGACY)
            continue;
-        if (version.size() >= 8 && base.size() >= 8 && version.compare(0, 8, base, 0, 8) == 0)
-            return true;
+        if (series == base)
+            return i;
    }
-    return false;
+    return AVAILABLE_NETWORK_VERSIONS_COUNT;
+}
+
+// True when a whitelisted series can load the version through an ABI this build implements.
+inline bool is_supported_network_version(const std::string& version) {
+    return find_network_version_index(version) < AVAILABLE_NETWORK_VERSIONS_COUNT;
+}
+
+// The generation to call a loaded library through. Unsupported for anything the load gate rejects,
+// so a mislabelled library reaches no plug-in call instead of a layout it does not share.
+inline NetworkAbi network_plugin_abi(const std::string& version) {
+    const size_t i = find_network_version_index(version);
+    return i < AVAILABLE_NETWORK_VERSIONS_COUNT ? AVAILABLE_NETWORK_VERSIONS[i].abi : NetworkAbi::Unsupported;
 }

 struct NetworkLibraryVersionInfo {
@@ -441,15 +527,6 @@ inline std::string extract_suffix(const std::string& full_version) {
    return (pos == std::string::npos) ? "" : full_version.substr(pos + 1);
 }

-// The AA.BB.CC series of a modern version string - the plug-in's stored identity. The 4th
-// component is only which build of the series happens to be installed and is read live from
-// the loaded plug-in for display. Legacy keeps its exact string (the shim matches exactly).
-inline std::string network_plugin_series(const std::string& version) {
-    if (version.empty() || version == BAMBU_NETWORK_AGENT_VERSION_LEGACY)
-        return version;
-    return version.size() >= 8 ? version.substr(0, 8) : version;
-}
-
 // True when the version is a pure dotted-numeric build (AA.BB.CC or AA.BB.CC.DD) whose identity
 // collapses to its series - the managed/OTA build. Legacy and any custom-named build
 // (02.08.01_custom, 02.08.01.52-dev) are NOT managed: they are genuinely distinct files kept
@@ -0,0 +1,274 @@
+#include "CustomWidgetsPlugin.hpp"
+
+#include "slic3r/GUI/Widgets/Button.hpp"
+#include "slic3r/GUI/Widgets/CheckBox.hpp"
+#include "slic3r/GUI/Widgets/TextInput.hpp"
+#include "slic3r/GUI/Widgets/SwitchButton.hpp"
+#include "slic3r/GUI/Widgets/ProgressBar.hpp"
+#include "slic3r/GUI/Widgets/Label.hpp"
+#include "slic3r/GUI/Widgets/LabeledStaticBox.hpp"
+
+#include <wx/window.h>
+#include <wx/tglbtn.h>
+
+wxString CustomWidgetsPlugin::GetName() const
+{
+    return "OrcaCustomWidgets";
+}
+
+bool CustomWidgetsPlugin::CanProvideProperties(wxClassInfo* info)
+{
+    return info->IsKindOf(CLASSINFO(wxWindow));
+}
+
+wxVector<wxInspector::PropertyDef> CustomWidgetsPlugin::GetProperties(
+    wxInspector::InspectableObject& obj)
+{
+    wxVector<wxInspector::PropertyDef> props;
+    wxWindow* win = obj.AsWindow();
+    if (!win) return props;
+
+    if (auto* btn = dynamic_cast<Button*>(win))
+        addButtonProps(btn, props);
+    if (auto* cb = dynamic_cast<CheckBox*>(win))
+        addCheckBoxProps(cb, props);
+    if (auto* ti = dynamic_cast<TextInput*>(win))
+        addTextInputProps(ti, props);
+    if (auto* sb = dynamic_cast<SwitchButton*>(win))
+        addSwitchButtonProps(sb, props);
+    if (auto* pb = dynamic_cast<ProgressBar*>(win))
+        addProgressBarProps(pb, props);
+    if (auto* lbl = dynamic_cast<Label*>(win))
+        addLabelProps(lbl, props);
+    if (auto* lsb = dynamic_cast<LabeledStaticBox*>(win))
+        addLabeledStaticBoxProps(lsb, props);
+
+    return props;
+}
+
+void CustomWidgetsPlugin::addButtonProps(Button* btn,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    wxVector<wxString> styleChoices;
+    styleChoices.push_back("Regular");
+    styleChoices.push_back("Confirm");
+    styleChoices.push_back("Alert");
+    styleChoices.push_back("Disabled");
+
+    auto styleToStr = [](ButtonStyle s) -> wxString {
+        switch (s) {
+            case ButtonStyle::Regular:  return "Regular";
+            case ButtonStyle::Confirm:  return "Confirm";
+            case ButtonStyle::Alert:    return "Alert";
+            case ButtonStyle::Disabled: return "Disabled";
+        }
+        return "Regular";
+    };
+
+    props.push_back({"Button Style", "Orca Button", PropertyType::Choice,
+        styleToStr(btn->GetStyle()), false, styleChoices,
+        [btn, styleToStr]() { return styleToStr(btn->GetStyle()); },
+        [btn](const wxString& v) {
+            ButtonStyle s = ButtonStyle::Regular;
+            if (v == "Confirm")       s = ButtonStyle::Confirm;
+            else if (v == "Alert")    s = ButtonStyle::Alert;
+            else if (v == "Disabled") s = ButtonStyle::Disabled;
+            btn->SetStyle(s, btn->GetType());
+            return true;
+        }});
+
+    wxVector<wxString> typeChoices;
+    typeChoices.push_back("Compact");
+    typeChoices.push_back("Window");
+    typeChoices.push_back("Choice");
+    typeChoices.push_back("Parameter");
+    typeChoices.push_back("Icon");
+    typeChoices.push_back("Expanded");
+
+    auto typeToStr = [](ButtonType t) -> wxString {
+        switch (t) {
+            case ButtonType::Compact:   return "Compact";
+            case ButtonType::Window:    return "Window";
+            case ButtonType::Choice:    return "Choice";
+            case ButtonType::Parameter: return "Parameter";
+            case ButtonType::Icon:      return "Icon";
+            case ButtonType::Expanded:  return "Expanded";
+        }
+        return "Compact";
+    };
+
+    props.push_back({"Button Type", "Orca Button", PropertyType::Choice,
+        typeToStr(btn->GetType()), false, typeChoices,
+        [btn, typeToStr]() { return typeToStr(btn->GetType()); },
+        [btn](const wxString& v) {
+            ButtonType t = ButtonType::Compact;
+            if (v == "Window")       t = ButtonType::Window;
+            else if (v == "Choice")    t = ButtonType::Choice;
+            else if (v == "Parameter") t = ButtonType::Parameter;
+            else if (v == "Icon")      t = ButtonType::Icon;
+            else if (v == "Expanded")  t = ButtonType::Expanded;
+            btn->SetStyle(btn->GetStyle(), t);
+            return true;
+        }});
+
+    props.push_back({"Selected", "Orca Button", PropertyType::Boolean,
+        btn->IsSelected() ? "true" : "false", false, {},
+        [btn]() { return btn->IsSelected() ? "true" : "false"; },
+        [btn](const wxString& v) {
+            btn->SetSelected(v == "true");
+            btn->Refresh();
+            return true;
+        }});
+}
+
+void CustomWidgetsPlugin::addCheckBoxProps(CheckBox* cb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Half Checked", "Orca CheckBox", PropertyType::Boolean,
+        cb->IsHalfChecked() ? "true" : "false", false, {},
+        [cb]() { return cb->IsHalfChecked() ? "true" : "false"; },
+        [cb](const wxString& v) {
+            cb->SetHalfChecked(v == "true");
+            return true;
+        }});
+}
+
+void CustomWidgetsPlugin::addTextInputProps(TextInput* ti,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Label", "Orca TextInput", PropertyType::String,
+        ti->GetLabel(), false, {},
+        [ti]() { return ti->GetLabel(); },
+        [ti](const wxString& v) { ti->SetLabel(v); return true; }});
+
+    props.push_back({"Text Value", "Orca TextInput", PropertyType::String,
+        ti->GetTextCtrl()->GetValue(), false, {},
+        [ti]() { return ti->GetTextCtrl()->GetValue(); },
+        [ti](const wxString& v) { ti->GetTextCtrl()->SetValue(v); return true; }});
+
+    props.push_back({"Corner Radius", "Orca TextInput", PropertyType::Integer,
+        wxString::Format("%d", ti->GetCornerRadius()), false, {},
+        [ti]() { return wxString::Format("%d", ti->GetCornerRadius()); },
+        [ti](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            ti->SetCornerRadius((double) val);
+            ti->Refresh();
+            return true;
+        }});
+}
+
+void CustomWidgetsPlugin::addSwitchButtonProps(SwitchButton* sb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Value", "Orca SwitchButton", PropertyType::Boolean,
+        sb->GetValue() ? "true" : "false", false, {},
+        [sb]() { return sb->GetValue() ? "true" : "false"; },
+        [sb](const wxString& v) {
+            sb->SetValue(v == "true");
+            return true;
+        }});
+}
+
+void CustomWidgetsPlugin::addProgressBarProps(ProgressBar* pb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Proportion", "Orca ProgressBar", PropertyType::String,
+        wxString::Format("%.2f", pb->m_proportion), false, {},
+        [pb]() { return wxString::Format("%.2f", pb->m_proportion); },
+        [pb](const wxString& v) {
+            double val;
+            if (wxSscanf(v, "%lf", &val) != 1) return false;
+            pb->m_proportion = val;
+            pb->Refresh();
+            return true;
+        }});
+
+    props.push_back({"Show Number", "Orca ProgressBar", PropertyType::Boolean,
+        pb->m_shownumber ? "true" : "false", false, {},
+        [pb]() { return pb->m_shownumber ? "true" : "false"; },
+        [pb](const wxString& v) {
+            pb->m_shownumber = (v == "true");
+            pb->Refresh();
+            return true;
+        }});
+}
+
+void CustomWidgetsPlugin::addLabelProps(Label* lbl,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    bool isHyperlink = (lbl->GetWindowStyleFlag() & LB_HYPERLINK) != 0;
+
+    props.push_back({"Is Hyperlink", "Orca Label", PropertyType::Boolean,
+        isHyperlink ? "true" : "false", true, {},
+        [lbl]() {
+            return (lbl->GetWindowStyleFlag() & LB_HYPERLINK) ? "true" : "false";
+        },
+        nullptr});
+
+    props.push_back({"Font Point Size", "Orca Label", PropertyType::ReadOnly,
+        wxString::Format("%d", lbl->GetFont().GetPointSize()), true, {},
+        [lbl]() {
+            return wxString::Format("%d", lbl->GetFont().GetPointSize());
+        },
+        nullptr});
+}
+
+void CustomWidgetsPlugin::addLabeledStaticBoxProps(LabeledStaticBox* lsb,
+    wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Corner Radius", "LabeledStaticBox", PropertyType::Integer,
+        wxString::Format("%d", lsb->GetCornerRadius()), false, {},
+        [lsb]() { return wxString::Format("%d", lsb->GetCornerRadius()); },
+        [lsb](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            lsb->SetCornerRadius((int) val);
+            return true;
+        }});
+
+    props.push_back({"Border Width", "LabeledStaticBox", PropertyType::Integer,
+        wxString::Format("%d", lsb->GetBorderWidth()), false, {},
+        [lsb]() { return wxString::Format("%d", lsb->GetBorderWidth()); },
+        [lsb](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            lsb->SetBorderWidth((int) val);
+            return true;
+        }});
+
+    // Border Color: display as hex string
+    wxColour bc = lsb->GetBorderColor().colorForStates(0);
+    props.push_back({"Border Color", "LabeledStaticBox", PropertyType::String,
+        bc.GetAsString(wxC2S_HTML_SYNTAX), false, {},
+        [lsb]() {
+            return lsb->GetBorderColor()
+                .colorForStates(0)
+                .GetAsString(wxC2S_HTML_SYNTAX);
+        },
+        [lsb](const wxString& v) {
+            wxColour c(v);
+            if (!c.IsOk()) return false;
+            lsb->SetBorderColor(StateColor(c));
+            return true;
+        }});
+
+    props.push_back({"Scale", "LabeledStaticBox", PropertyType::ReadOnly,
+        wxString::Format("%.2f", lsb->GetScale()), true, {},
+        [lsb]() { return wxString::Format("%.2f", lsb->GetScale()); },
+        nullptr});
+}
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <wx/inspector/plugin.h>
+
+class CustomWidgetsPlugin : public wxInspector::wxInspectorPlugin
+{
+public:
+    wxString GetName() const override;
+
+    bool CanProvideProperties(wxClassInfo* info) override;
+
+    wxVector<wxInspector::PropertyDef> GetProperties(
+        wxInspector::InspectableObject& obj) override;
+
+private:
+    void addButtonProps(class Button* btn,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addCheckBoxProps(class CheckBox* cb,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addTextInputProps(class TextInput* ti,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addSwitchButtonProps(class SwitchButton* sb,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addProgressBarProps(class ProgressBar* pb,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addLabelProps(class Label* lbl,
+        wxVector<wxInspector::PropertyDef>& props);
+    void addLabeledStaticBoxProps(class LabeledStaticBox* lsb,
+        wxVector<wxInspector::PropertyDef>& props);
+};
@@ -0,0 +1,82 @@
+#include "DPIAwarePlugin.hpp"
+
+#include "slic3r/GUI/GUI_Utils.hpp" // DPIFrame, DPIDialog, DPIAware<P>
+
+#include <wx/window.h>
+#include <wx/crt.h>
+
+namespace {
+
+template<typename T>
+void addDPIProps(T* dpi, wxVector<wxInspector::PropertyDef>& props)
+{
+    using namespace wxInspector;
+
+    props.push_back({"Scale Factor", "DPI Scaling", PropertyType::String,
+        wxString::Format("%.2f", dpi->scale_factor()), false, {},
+        [dpi]() { return wxString::Format("%.2f", dpi->scale_factor()); },
+        [dpi](const wxString& v) {
+            double val;
+            if (wxSscanf(v, "%lf", &val) != 1) return false;
+            dpi->set_scale_factor((float) val);
+            return true;
+        }});
+
+    props.push_back({"Prev Scale Factor", "DPI Scaling", PropertyType::String,
+        wxString::Format("%.2f", dpi->prev_scale_factor()), false, {},
+        [dpi]() { return wxString::Format("%.2f", dpi->prev_scale_factor()); },
+        [dpi](const wxString& v) {
+            double val;
+            if (wxSscanf(v, "%lf", &val) != 1) return false;
+            dpi->set_prev_scale_factor((float) val);
+            return true;
+        }});
+
+    props.push_back({"EM Unit", "DPI Scaling", PropertyType::Integer,
+        wxString::Format("%d", dpi->em_unit()), false, {},
+        [dpi]() { return wxString::Format("%d", dpi->em_unit()); },
+        [dpi](const wxString& v) {
+            long val;
+            if (!v.ToLong(&val)) return false;
+            dpi->set_em_unit((int) val);
+            return true;
+        }});
+
+    props.push_back({"Normal Font", "DPI Scaling", PropertyType::ReadOnly,
+        dpi->normal_font().GetNativeFontInfoDesc(), true, {},
+        [dpi]() { return dpi->normal_font().GetNativeFontInfoDesc(); },
+        nullptr});
+
+    props.push_back({"Force Rescale", "DPI Scaling", PropertyType::Boolean,
+        dpi->force_rescale() ? "true" : "false", true, {},
+        [dpi]() { return dpi->force_rescale() ? "true" : "false"; },
+        nullptr});
+}
+
+} // anonymous namespace
+
+wxString DPIAwarePlugin::GetName() const
+{
+    return "OrcaDPIAware";
+}
+
+bool DPIAwarePlugin::CanProvideProperties(wxClassInfo* info)
+{
+    return info->IsKindOf(CLASSINFO(wxWindow));
+}
+
+wxVector<wxInspector::PropertyDef> DPIAwarePlugin::GetProperties(
+    wxInspector::InspectableObject& obj)
+{
+    wxVector<wxInspector::PropertyDef> props;
+    wxWindow* win = obj.AsWindow();
+    if (!win) return props;
+
+    if (auto* frame = dynamic_cast<Slic3r::GUI::DPIFrame*>(win)) {
+        addDPIProps(frame, props);
+    } else if (auto* dlg = dynamic_cast<Slic3r::GUI::DPIDialog*>(win)) {
+        addDPIProps(dlg, props);
+    }
+
+    return props;
+}
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <wx/inspector/plugin.h>
+
+class DPIAwarePlugin : public wxInspector::wxInspectorPlugin
+{
+public:
+    wxString GetName() const override;
+
+    bool CanProvideProperties(wxClassInfo* info) override;
+
+    wxVector<wxInspector::PropertyDef> GetProperties(
+        wxInspector::InspectableObject& obj) override;
+};
@@ -0,0 +1,14 @@
+#pragma once
+
+#include "DPIAwarePlugin.hpp"
+#include "CustomWidgetsPlugin.hpp"
+
+#include <wx/inspector/inspector.h>
+
+inline void RegisterOrcaInspectorPlugins()
+{
+    static DPIAwarePlugin          dpiaware;
+    static CustomWidgetsPlugin     customWidgets;
+    wxInspector::RegisterPlugin(&dpiaware);
+    wxInspector::RegisterPlugin(&customWidgets);
+}
@@ -491,17 +491,6 @@ SCENARIO("init_print functionality", "[test_helpers]") {
 			THEN("Export gcode functions outputs text.") {
 				REQUIRE(! Slic3r::Test::gcode(print).empty());
 			}
-#if 0
-			THEN("Embedded meshes exported") {
-				std::string path = "C:\\data\\temp\\embedded_meshes\\";
-				for (auto kvp : Slic3r::Test::mesh_names) {
-					Slic3r::TriangleMesh m = mesh(kvp.first);
-					std::string name = kvp.second;
-					REQUIRE(Slic3r::store_stl((path + name + ".stl").c_str(), &m, true) == true);
-					REQUIRE(Slic3r::store_obj((path + name + ".obj").c_str(), &m) == true);
-				}
-			}
-#endif
 		}
 	}
 }
@@ -9,6 +9,8 @@
 #include "libslic3r/MultiNozzleUtils.hpp"
 #include "libslic3r/ProjectTask.hpp"

+#include "test_utils.hpp"
+
 #include <boost/filesystem/operations.hpp>

 #include <catch2/catch_tostring.hpp>
@@ -109,8 +111,8 @@ SCENARIO("Export+Import geometry to/from 3mf file cycle", "[3mf]") {
        src_object->instances.front()->set_transformation(src_instance_transform);

        WHEN("model is saved+loaded to/from 3mf file") {
-            // save the model to 3mf file
-            std::string test_file = std::string(TEST_DATA_DIR) + "/test_3mf/prusa.3mf";
+            ScopedTemporaryFile temp(".3mf");
+            const std::string test_file = temp.string();
            store_3mf(test_file.c_str(), &src_model, nullptr, false);

            // load back the model from the 3mf file
@@ -120,7 +122,6 @@ SCENARIO("Export+Import geometry to/from 3mf file cycle", "[3mf]") {
                ConfigSubstitutionContext ctxt{ ForwardCompatibilitySubstitutionRule::Disable };
                load_3mf(test_file.c_str(), dst_config, ctxt, &dst_model, false);
            }
-            boost::filesystem::remove(test_file);

            // compare meshes
            TriangleMesh src_mesh = src_model.mesh();
@@ -522,7 +523,7 @@ SCENARIO("2D convex hull of sinking object", "[3mf][.]") {
            object->center_around_origin(false);

 	    // This outputs the same exact data as the Prusaslicer test
-	    object->volumes[0]->mesh().write_ascii("/tmp/orca.ascii");
+	    write_debug_stl("3mf/orca.ascii", object->volumes[0]->mesh());

            // set instance's attitude so that it is rotated, scaled (and sinking? how is it sinking? the rotation? does it matter if it's sinking?)
            ModelInstance* instance = object->instances[0];
@@ -73,6 +73,40 @@ TEST_CASE("apply_override fills nil entries from the 0-based default index", "[C
    }
 }

+TEST_CASE("support_different_extruders is true only when the printer defines more than one variant column", "[Config]")
+{
+    int extruder_count = 0;
+
+    SECTION("a non-Bambu dual-nozzle printer with one variant column reports false") {
+        DynamicPrintConfig config;
+        config.option<ConfigOptionFloats>("nozzle_diameter", true)->values = {0.4, 0.4};
+        // Both extruders resolve to the same default variant, so there is only one column.
+        config.option<ConfigOptionStrings>("extruder_variant_list", true)->values = {"Direct Drive Standard",
+                                                                                     "Direct Drive Standard"};
+        REQUIRE(config.support_different_extruders(extruder_count) == false);
+        REQUIRE(extruder_count == 2);
+    }
+
+    SECTION("a Bambu H2D-style printer with distinct variants reports true") {
+        DynamicPrintConfig config;
+        config.option<ConfigOptionFloats>("nozzle_diameter", true)->values = {0.4, 0.4};
+        config.option<ConfigOptionStrings>("extruder_variant_list", true)->values = {
+            "Direct Drive Standard,Direct Drive High Flow",
+            "Direct Drive Standard,Direct Drive High Flow,Direct Drive TPU High Flow"};
+        REQUIRE(config.support_different_extruders(extruder_count) == true);
+        REQUIRE(extruder_count == 2);
+    }
+
+    SECTION("a many-toolhead printer that never opts into variants reports false") {
+        // A Snapmaker U1 has four identical toolheads and never defines extruder_variant_list,
+        // so the config falls back to a single default variant token.
+        DynamicPrintConfig config;
+        config.option<ConfigOptionFloats>("nozzle_diameter", true)->values = {0.4, 0.4, 0.4, 0.4};
+        REQUIRE(config.support_different_extruders(extruder_count) == false);
+        REQUIRE(extruder_count == 4);
+    }
+}
+
 TEST_CASE("get_config_index_base resolves (volume type, extruder type, id) to a slot", "[Config]")
 {
    const std::vector<std::string> variant_list = {"Direct Drive Standard", "Direct Drive High Flow",
@@ -4,6 +4,8 @@

 #include "libslic3r/SLA/Hollowing.hpp"

+#include "test_utils.hpp"
+
 TEST_CASE("Hollow two overlapping spheres") {
    using namespace Slic3r;

@@ -16,6 +18,6 @@ TEST_CASE("Hollow two overlapping spheres") {

    sla::hollow_mesh(sphere1, sla::HollowingConfig{}, sla::HollowingFlags::hfRemoveInsideTriangles);

-    sphere1.WriteOBJFile("twospheres.obj");
+    write_debug_obj("hollowing/twospheres.obj", sphere1);
 }

@@ -5,6 +5,8 @@

 #include "libslic3r/TriangleMesh.hpp"

+#include "test_utils.hpp"
+
 using namespace Slic3r;

 TEST_CASE("Split empty mesh", "[its_split][its]") {
@@ -29,13 +31,15 @@ TEST_CASE("Split simple mesh consisting of one part", "[its_split][its]") {
    REQUIRE(res.front().vertices.size() == cube.vertices.size());
 }

+// Dump each split part as its own OBJ for eyeballing; no-op in release.
 void debug_write_obj(const std::vector<indexed_triangle_set> &res, const std::string &name)
 {
 #ifndef NDEBUG
    size_t part_idx = 0;
-    for (auto &part_its : res) {
-        its_write_obj(part_its, (name + std::to_string(part_idx++) + ".obj").c_str());
-    }
+    for (const auto &part_its : res)
+        write_debug_obj("indexed_triangle_set/" + name + std::to_string(part_idx++) + ".obj", part_its);
+#else
+    (void) res; (void) name;
 #endif
 }

@@ -260,7 +264,6 @@ TEST_CASE("Reduce one edge by Quadric Edge Collapse", "[its]")
    CHECK(is_similar(its_, its, cfg));
 }

-#include "test_utils.hpp"
 TEST_CASE("Simplify mesh by Quadric edge collapse to 5%", "[its]")
 {
    TriangleMesh mesh = load_model("frog_legs.obj");
@@ -191,22 +191,21 @@ static void test_expolys(Rst&& rst, const ExPolygons& ref, Vec2i32 window, const
    for (const ExPolygon& expoly : ref)
        rst.draw(expoly);

-    std::fstream out(name + ".png", std::ios::out);
-    out << rst.encode(sla::PNGRasterEncoder{});
-    out.close();
+    write_debug_stream("marchingsquares/" + name + ".png",
+                       [&] { return rst.encode(sla::PNGRasterEncoder{}); });

    const ExPolygons bmp = rstGetPolys(rst);
    const ExPolygons ext = sla::raster_to_polygons(rst, window);

-    SVG svg(name + ".svg", raster_bb);
-    svg.draw(bmp, "green");
-    if (pixel_size.x() >= scale_(0.5))
-        svg.draw_grid(raster_bb, "grey", scale_(0.05), pixel_size.x());
-    if (window_size.x() >= scale_(1.0))
-        svg.draw_grid(raster_bb, "grey", scale_(0.10), window_size.x());
-    svg.draw_outline(ref, "red", "red", scale_(0.3));
-    svg.draw_outline(ext, "blue", "blue");
-    svg.Close();
+    write_debug_svg("marchingsquares/" + name + ".svg", raster_bb, [&](SVG &svg) {
+        svg.draw(bmp, "green");
+        if (pixel_size.x() >= scale_(0.5))
+            svg.draw_grid(raster_bb, "grey", scale_(0.05), pixel_size.x());
+        if (window_size.x() >= scale_(1.0))
+            svg.draw_grid(raster_bb, "grey", scale_(0.10), window_size.x());
+        svg.draw_outline(ref, "red", "red", scale_(0.3));
+        svg.draw_outline(ext, "blue", "blue");
+    });

    // Note all these areas are unscaled back to mm^2.
    double raster_area    = unscaled(unscaled(area(bmp)));
@@ -432,9 +431,7 @@ static void recreate_object_from_rasters(const std::string& objname, float lh)
    double          disp_w = 120.96;
    double          disp_h = 68.04;

-#ifndef NDEBUG
    size_t cntr = 0;
-#endif
    for (ExPolygons& layer : layers) {
        auto rst = create_raster(res, disp_w, disp_h);

@@ -442,11 +439,8 @@ static void recreate_object_from_rasters(const std::string& objname, float lh)
            rst.draw(island);
        }

-#ifndef NDEBUG
-        std::fstream out(objname + std::to_string(cntr) + ".png", std::ios::out);
-        out << rst.encode(sla::PNGRasterEncoder{});
-        out.close();
-#endif
+        write_debug_stream("marchingsquares/" + objname + std::to_string(cntr) + ".png",
+                           [&] { return rst.encode(sla::PNGRasterEncoder{}); });

        ExPolygons layer_ = sla::raster_to_polygons(rst);
        //        float delta = scaled(std::min(rst.pixel_dimensions().h_mm,
@@ -454,21 +448,19 @@ static void recreate_object_from_rasters(const std::string& objname, float lh)

        //        layer_ = expolygons_simplify(layer_, delta);

-#ifndef NDEBUG
-        SVG svg(objname + std::to_string(cntr) + ".svg", rstBBox(rst));
-        svg.draw(layer_);
-        svg.draw(layer, "green");
-        svg.Close();
-#endif
+        write_debug_svg("marchingsquares/" + objname + std::to_string(cntr) + ".svg", rstBBox(rst),
+                        [&](SVG &svg) {
+            svg.draw(layer_);
+            svg.draw(layer, "green");
+        });

        double layera = 0., layera_ = 0.;
        for (auto& p : layer)
            layera += p.area();
        for (auto& p : layer_)
            layera_ += p.area();
-#ifndef NDEBUG
-        std::cout << cntr++ << std::endl;
-#endif
+        ++cntr;
+
        double diff = std::abs(layera_ - layera);
        REQUIRE((diff <= 0.1 * layera || diff < scaled<double>(1.) * scaled<double>(1.)));

@@ -477,7 +469,7 @@ static void recreate_object_from_rasters(const std::string& objname, float lh)

    indexed_triangle_set out = slices_to_mesh(layers, bb.min.z(), double(lh), double(lh));

-    its_write_obj(out, "out_from_rasters.obj");
+    write_debug_obj("marchingsquares/out_from_rasters.obj", out);
 }

 TEST_CASE("Recreate object from rasters", "[SL1Import]") { recreate_object_from_rasters("frog_legs.obj", 0.05f); }
@@ -229,7 +229,7 @@ TEST_CASE("halfcone test", "[halfcone]") {
    indexed_triangle_set m = sla::get_mesh(br, 45);

    its_merge_vertices(m);
-    its_write_obj(m, "Halfcone.obj");
+    write_debug_obj("sla_print/Halfcone.obj", m);
 }

 TEST_CASE("Test concurrency")
@@ -13,7 +13,7 @@ TEST_CASE("Overhanging point should be supported", "[SupGen]") {
    // Pyramid with 45 deg slope
    TriangleMesh mesh = make_pyramid(10.f, 10.f);
    mesh.rotate_y(float(PI));
-    mesh.WriteOBJFile("Pyramid.obj");
+    write_debug_obj("sla_supptgen/Pyramid.obj", mesh);

    sla::SupportPoints pts = calc_support_pts(mesh);

@@ -55,7 +55,7 @@ TEST_CASE("Overhanging horizontal surface should be supported", "[SupGen]") {

    TriangleMesh mesh = make_cube(width, depth, height);
    mesh.translate(0., 0., 5.); // lift up
-    mesh.WriteOBJFile("Cuboid.obj");
+    write_debug_obj("sla_supptgen/Cuboid.obj", mesh);

    sla::SupportPointGenerator::Config cfg;
    sla::SupportPoints pts = calc_support_pts(mesh, cfg);
@@ -81,7 +81,7 @@ TEST_CASE("Overhanging edge should be supported", "[SupGen]") {
    TriangleMesh mesh = make_prism(width, depth, height);
    mesh.rotate_y(float(PI)); // rotate on its back
    mesh.translate(0., 0., height);
-    mesh.WriteOBJFile("Prism.obj");
+    write_debug_obj("sla_supptgen/Prism.obj", mesh);

    sla::SupportPointGenerator::Config cfg;
    sla::SupportPoints pts = calc_support_pts(mesh, cfg);
@@ -106,7 +106,7 @@ TEST_CASE("Hollowed cube should be supported from the inside", "[SupGen][Hollowe

    hollow_mesh(mesh, HollowingConfig{});

-    mesh.WriteOBJFile("cube_hollowed.obj");
+    write_debug_obj("sla_supptgen/cube_hollowed.obj", mesh);

    auto bb = mesh.bounding_box();
    auto h  = float(bb.max.z() - bb.min.z());
@@ -129,7 +129,7 @@ TEST_CASE("Two parallel plates should be supported", "[SupGen][Hollowed]")
    mesh_high.translate(0., 0., 10.); // lift up
    mesh.merge(mesh_high);

-    mesh.WriteOBJFile("parallel_plates.obj");
+    write_debug_obj("sla_supptgen/parallel_plates.obj", mesh);

    sla::SupportPointGenerator::Config cfg;
    sla::SupportPoints pts = calc_support_pts(mesh, cfg);
@@ -47,8 +47,9 @@ void test_support_model_collision(const std::string          &obj_filename,
        notouch = notouch && area(intersections) < PI * pinhead_r * pinhead_r;
    }
    
-    /*if (!notouch) */export_failed_case(support_slices, byproducts);
-    
+    if (!notouch)
+        export_failed_case(support_slices, byproducts);
+
    REQUIRE(notouch);
 }

@@ -62,11 +63,11 @@ void export_failed_case(const std::vector<ExPolygons> &support_slices, const Sup
        std::stringstream ss;
        if (!intersections.empty()) {
            ss << byproducts.obj_fname << std::setprecision(4) << n << ".svg";
-            SVG svg(ss.str());
-            svg.draw(sup_slice, "green");
-            svg.draw(mod_slice, "blue");
-            svg.draw(intersections, "red");
-            svg.Close();
+            write_debug_svg("sla/" + ss.str(), [&](SVG &svg) {
+                svg.draw(sup_slice, "green");
+                svg.draw(mod_slice, "blue");
+                svg.draw(intersections, "red");
+            });
        }
    }

@@ -74,8 +75,8 @@ void export_failed_case(const std::vector<ExPolygons> &support_slices, const Sup
    byproducts.supporttree.retrieve_full_mesh(its);
    TriangleMesh m{its};
    m.merge(byproducts.input_mesh);
-    m.WriteOBJFile((Catch::getResultCapture().getCurrentTestName() + "_" +
-                    byproducts.obj_fname).c_str());
+    write_debug_obj("sla/" + Catch::getResultCapture().getCurrentTestName() +
+                    "_" + byproducts.obj_fname, m);
 }

 void test_supports(const std::string          &obj_filename,
@@ -350,13 +351,11 @@ void check_raster_transformations(sla::RasterBase::Orientation o, sla::RasterBas
    REQUIRE((w < res.width_px && h < res.height_px));
    
    auto px = raster.read_pixel(w, h);
-    
-    if (px != FullWhite) {
-        std::fstream outf("out.png", std::ios::out);
-        
-        outf << raster.encode(sla::PNGRasterEncoder());
-    }
-    
+
+    if (px != FullWhite)
+        write_debug_stream("sla/raster_transform_mismatch.png",
+                           [&] { return raster.encode(sla::PNGRasterEncoder()); });
+
    REQUIRE(px == FullWhite);
 }

@@ -85,7 +85,8 @@ TEST_CASE_METHOD(PluginFolderFixture, "Managed builds fold into the series; cust
 {
    add_plugin("02.08.01.55");          // managed, same series -> folded into the 02.08.01 row
    add_plugin("02.09.00.10");          // managed, unknown series -> not listed
-    add_plugin("02.03.00.62");          // managed, series no longer whitelisted -> not listed
+    add_plugin("02.03.00.62");          // managed, older whitelisted series -> folded into 02.03.00
+    add_plugin("02.01.01.52");          // managed, series with no ABI in this build -> not listed
    add_plugin("02.08.01_custom");      // custom, whitelisted series -> listed under it
    add_plugin("02.08.01.52-dev");      // custom (dash-suffixed), whitelisted series -> listed

@@ -96,17 +97,24 @@ TEST_CASE_METHOD(PluginFolderFixture, "Managed builds fold into the series; cust
    REQUIRE(count_version(versions, "02.08.01")    == 1);
    REQUIRE(count_version(versions, "02.09.00.10") == 0);
    REQUIRE(count_version(versions, "02.03.00.62") == 0);
+    REQUIRE(count_version(versions, "02.03.00")    == 1);
+    REQUIRE(count_version(versions, "02.01.01.52") == 0);
    // Custom-named builds are distinct files kept under their own name.
    REQUIRE(count_version(versions, "02.08.01_custom")  == 1);
    REQUIRE(count_version(versions, "02.08.01.52-dev")  == 1);

    // Newest series first, its customs nested under it (suffix sort: "" < ".52-dev" < "_custom"),
-    // legacy last.
+    // then older series, legacy last.
    REQUIRE(versions[0].version == "02.08.01");
    REQUIRE(versions[1].version == "02.08.01.52-dev");
    REQUIRE(versions[2].version == "02.08.01_custom");
+    REQUIRE(versions[3].version == "02.03.00");
    REQUIRE(versions.back().version == BAMBU_NETWORK_AGENT_VERSION_LEGACY);

+    // An older whitelisted series is a flat row of its own, and never holds "(Latest)".
+    REQUIRE(versions[3].suffix.empty());
+    REQUIRE_FALSE(versions[3].is_latest);
+
    // Customs sort/render nested under their series (non-empty suffix, base = the series).
    REQUIRE(versions[1].base_version == "02.08.01");
    REQUIRE_FALSE(versions[1].suffix.empty());
@@ -137,6 +145,16 @@ TEST_CASE_METHOD(PluginFolderFixture, "Only the loaded series is marked installe
        REQUIRE(marked == 1);
    }

+    // An older series is marked the same way, and never bleeds onto the latest row.
+    {
+        add_plugin("02.03.00.62");
+        auto versions = get_all_available_versions("02.03.00.62");
+        int marked = 0;
+        for (const auto& info : versions)
+            if (info.is_loaded) { ++marked; REQUIRE(info.version == "02.03.00"); }
+        REQUIRE(marked == 1);
+    }
+
    // A loaded custom build matches its own row, never the bare series.
    {
        auto versions = get_all_available_versions("02.08.01_custom");
@@ -153,19 +171,25 @@ TEST_CASE_METHOD(PluginFolderFixture, "Only the loaded series is marked installe

 TEST_CASE("Only whitelisted series pass the load gate", "[NetworkVersions]")
 {
-    // The whitelisted series, its builds, and custom-named builds of that series.
+    // Each whitelisted series, its builds, and custom-named builds of that series.
    REQUIRE(is_supported_network_version("02.08.01"));
    REQUIRE(is_supported_network_version("02.08.01.52"));
    REQUIRE(is_supported_network_version("02.08.01.55"));
    REQUIRE(is_supported_network_version("02.08.01_custom"));
    REQUIRE(is_supported_network_version("02.08.01.52-dev"));
+    REQUIRE(is_supported_network_version("02.03.00"));
+    REQUIRE(is_supported_network_version("02.03.00.62"));
+    REQUIRE(is_supported_network_version("02.03.00.70"));
+    REQUIRE(is_supported_network_version("02.03.00_custom"));
    REQUIRE(is_supported_network_version(BAMBU_NETWORK_AGENT_VERSION_LEGACY));

-    // Series whitelisted by previous Orca releases - their ABI no longer matches.
-    REQUIRE_FALSE(is_supported_network_version("02.03.00.62"));
+    // Series whitelisted by previous Orca releases that no generation here can call.
    REQUIRE_FALSE(is_supported_network_version("02.01.01.52"));
    REQUIRE_FALSE(is_supported_network_version("02.00.02.50"));

+    // A neighbouring series of a whitelisted one is still its own ABI.
+    REQUIRE_FALSE(is_supported_network_version("02.03.01.51"));
+
    // Unknown series, legacy siblings, and malformed values.
    REQUIRE_FALSE(is_supported_network_version("02.09.00.10"));
    std::string legacy = BAMBU_NETWORK_AGENT_VERSION_LEGACY;
@@ -175,6 +199,30 @@ TEST_CASE("Only whitelisted series pass the load gate", "[NetworkVersions]")
    REQUIRE_FALSE(is_supported_network_version("02.08"));
 }

+TEST_CASE("Each version resolves to the ABI generation that can call it", "[NetworkVersions]")
+{
+    // The generation is keyed on the series, so every build of a series - including the
+    // custom-named ones - resolves to the same one.
+    CHECK(network_plugin_abi("02.08.01")        == NetworkAbi::Current);
+    CHECK(network_plugin_abi("02.08.01.55")     == NetworkAbi::Current);
+    CHECK(network_plugin_abi("02.08.01.52-dev") == NetworkAbi::Current);
+    CHECK(network_plugin_abi("02.03.00")        == NetworkAbi::V0203);
+    CHECK(network_plugin_abi("02.03.00.62")     == NetworkAbi::V0203);
+    CHECK(network_plugin_abi("02.03.00_custom") == NetworkAbi::V0203);
+    CHECK(network_plugin_abi(BAMBU_NETWORK_AGENT_VERSION_LEGACY) == NetworkAbi::Legacy);
+
+    // Anything the load gate rejects must dispatch through nothing at all, rather than
+    // defaulting to a layout it does not share.
+    CHECK(network_plugin_abi("02.01.01.52") == NetworkAbi::Unsupported);
+    CHECK(network_plugin_abi("02.00.02.50") == NetworkAbi::Unsupported);
+    CHECK(network_plugin_abi("02.09.00.10") == NetworkAbi::Unsupported);
+    CHECK(network_plugin_abi("")            == NetworkAbi::Unsupported);
+
+    // A series may only be offered once the dispatch layer implements its generation.
+    for (size_t i = 0; i < AVAILABLE_NETWORK_VERSIONS_COUNT; ++i)
+        CHECK(AVAILABLE_NETWORK_VERSIONS[i].abi != NetworkAbi::Unsupported);
+}
+
 TEST_CASE_METHOD(PluginFolderFixture, "Legacy series never adopts discovered builds", "[NetworkVersions]")
 {
    // A different build of the legacy series must not be surfaced: is_legacy_version()
@@ -3,9 +3,14 @@

 #include <libslic3r/TriangleMesh.hpp>
 #include <libslic3r/Format/OBJ.hpp>
+#include <libslic3r/SVG.hpp>

 #include <boost/filesystem.hpp>

+#include <cstdio>
+#include <fstream>
+#include <string>
+
 #if defined(WIN32) || defined(_WIN32)
 #define PATH_SEPARATOR R"(\)"
 #else
@@ -44,4 +49,98 @@ private:
    boost::filesystem::path m_path;
 };

+// ---------------------------------------------------------------------------
+// Debug-only test artifacts
+//
+// Files a test dumps for inspection: a mesh, an SVG, or any streamable blob such
+// as a PNG. In debug builds each run writes to a fresh temp folder (path printed
+// once); the name may include a subfolder (e.g. "marchingsquares/foo.svg").
+// ---------------------------------------------------------------------------
+
+// Maps name to a path under the run's temp folder, creating any parent dirs
+// (forward slashes work on Windows). Not gated, so only call it from a
+// write_debug_* helper or inside an #ifndef NDEBUG block.
+inline std::string debug_artifact_path(const std::string &name)
+{
+    static const boost::filesystem::path root = [] {
+        boost::filesystem::path dir = boost::filesystem::temp_directory_path()
+            / boost::filesystem::unique_path("orca-test-artifacts-%%%%-%%%%");
+        boost::filesystem::create_directories(dir);
+        std::printf("Debug test artifacts will be written to %s\n", dir.string().c_str());
+        return dir;
+    }();
+    boost::filesystem::path full = root / name;
+    boost::filesystem::create_directories(full.parent_path());
+    return full.string();
+}
+
+// Dump a mesh as OBJ.
+inline void write_debug_obj(const std::string &name, const Slic3r::TriangleMesh &mesh)
+{
+#ifndef NDEBUG
+    mesh.WriteOBJFile(debug_artifact_path(name).c_str());
+#else
+    (void) name; (void) mesh;
+#endif
+}
+
+inline void write_debug_obj(const std::string &name, const indexed_triangle_set &its)
+{
+#ifndef NDEBUG
+    its_write_obj(its, debug_artifact_path(name).c_str());
+#else
+    (void) name; (void) its;
+#endif
+}
+
+// Dump a mesh as ASCII STL.
+inline void write_debug_stl(const std::string &name, const Slic3r::TriangleMesh &mesh)
+{
+#ifndef NDEBUG
+    mesh.write_ascii(debug_artifact_path(name).c_str());
+#else
+    (void) name; (void) mesh;
+#endif
+}
+
+// Draw an SVG artifact through a callback that receives the open SVG. Second
+// overload takes a BoundingBox when the drawing needs one.
+template<class Draw>
+inline void write_debug_svg(const std::string &name, Draw &&draw)
+{
+#ifndef NDEBUG
+    Slic3r::SVG svg(debug_artifact_path(name));
+    draw(svg);
+    svg.Close();
+#else
+    (void) name; (void) draw;
+#endif
+}
+
+template<class Draw>
+inline void write_debug_svg(const std::string &name, const Slic3r::BoundingBox &bbox, Draw &&draw)
+{
+#ifndef NDEBUG
+    Slic3r::SVG svg(debug_artifact_path(name), bbox);
+    draw(svg);
+    svg.Close();
+#else
+    (void) name; (void) bbox; (void) draw;
+#endif
+}
+
+// Write a callback's result (e.g. raster.encode(sla::PNGRasterEncoder{})) to an
+// artifact. operator<< is resolved by ADL at the call site, so this header needn't
+// include the producer's headers.
+template<class Produce>
+inline void write_debug_stream(const std::string &name, Produce &&produce)
+{
+#ifndef NDEBUG
+    std::ofstream out(debug_artifact_path(name), std::ios::out | std::ios::binary);
+    out << produce();
+#else
+    (void) name; (void) produce;
+#endif
+}
+
 #endif // SLIC3R_TEST_UTILS