Merge branch 'feat/plugin-feature' into feature/speed-dial

Adapt the speed dial's ActionRegistry to the collapsed get_plugin_capability(PluginCapabilityId) overload, and restore the script success/skipped status message the dialog lost when its PluginScriptRunner refactor was superseded by ActionRegistry.
2026-09-10 18:56:13 +00:00 · 2026-07-17 19:32:44 +08:00
parent b4f6573753 f6ff15ed99
commit f0f496e9c3
58 changed files with 4375 additions and 671 deletions
--- a/src/slic3r/GUI/ActionRegistry.cpp
+++ b/src/slic3r/GUI/ActionRegistry.cpp
@@ -114,7 +114,7 @@ std::unique_ptr<AppAction> make_action(const std::string& plugin_key, const std:
    if (!manager.is_plugin_loaded(plugin_key))
        return nullptr;
    // only_enabled defaults true, so a disabled capability resolves to nullptr here.
-    if (!manager.get_plugin_capability(plugin_key, capability, PluginCapabilityType::Script))
+    if (!manager.get_plugin_capability({PluginCapabilityType::Script, capability, plugin_key}))
        return nullptr;
    return std::make_unique<PluginScriptAction>(plugin_key, capability, source_name);
 }
--- a/src/slic3r/GUI/Field.cpp
+++ b/src/slic3r/GUI/Field.cpp
@@ -23,6 +23,8 @@
 #include "OG_CustomCtrl.hpp"
 #include "MsgDialog.hpp"
 #include "BitmapComboBox.hpp"
+#include "PluginsConfigDialog.hpp"
+#include "Widgets/Button.hpp"

 // BBS
 #include "Notebook.hpp"
@@ -1995,8 +1997,6 @@ void Choice::msw_rescale()

 void PluginField::BUILD()
 {
-    // Wrap the dynamic rows in a single container panel so the field is a proper window-field
-    // (getWindow() != null). The panel owns m_main_sizer; all row controls are children of it.
    auto* panel = new wxPanel(m_parent, wxID_ANY);
    wxGetApp().UpdateDarkUI(panel);
    window = panel;
@@ -2004,7 +2004,6 @@ void PluginField::BUILD()
    m_main_sizer = new wxBoxSizer(wxVERTICAL);
    panel->SetSizer(m_main_sizer);

-    // Initialize with default values or empty
    if (m_opt.type == coStrings) {
        const ConfigOptionStrings* vec = m_opt.get_default_value<ConfigOptionStrings>();
        if (vec != nullptr && !vec->values.empty()) {
@@ -2095,13 +2094,11 @@ void PluginField::add_plugin_row(const wxString& value, bool is_last)
    const auto button_size = wxSize(def_width_thinner() * m_em_unit, -1);
    auto row_sizer = new wxBoxSizer(wxHORIZONTAL);

-    // Select button with search icon
    ScalableButton* select_btn = new ScalableButton(window, wxID_ANY, "search", wxEmptyString,
        button_size, wxDefaultPosition, wxBU_EXACTFIT | wxNO_BORDER, true, 16);
    wxGetApp().UpdateDarkUI(select_btn);
    select_btn->SetToolTip(_L("Select plugin"));

-    // Display text control
    wxTextCtrl* display = new wxTextCtrl(window, wxID_ANY, value,
        wxDefaultPosition, wxSize(def_width_wider() * m_em_unit, wxDefaultCoord),
        wxTE_READONLY);
@@ -2117,7 +2114,6 @@ void PluginField::add_plugin_row(const wxString& value, bool is_last)
        remove_btn->SetToolTip(_L("Remove plugin"));
    }

-    // Add button (only on last row)
    ScalableButton* add_btn = nullptr;
    if (is_last && !m_opt.readonly) {
        add_btn = new ScalableButton(window, wxID_ANY, "param_add", wxEmptyString,
@@ -2238,7 +2234,6 @@ void PluginField::set_value(const boost::any& value, bool change_event)
 {
    m_disable_change_event = !change_event;

-    // Handle different input types
    if (value.empty()) {
        m_values.clear();
    } else if (value.type() == typeid(std::vector<std::string>)) {
@@ -2309,6 +2304,126 @@ void PluginField::msw_rescale()
    rebuild_ui();
 }

+namespace {
+
+// The stored text as a document, or an empty array when it is absent or unparseable.
+nlohmann::json plugin_overrides_as_json(const std::string& text)
+{
+    if (text.empty())
+        return nlohmann::json::array();
+    return nlohmann::json::parse(text, nullptr, /* allow_exceptions */ false);
+}
+
+} // namespace
+
+void PluginConfigField::BUILD()
+{
+    m_button = new ::Button(m_parent, _L("Configure"));
+    // ButtonType::Parameter gives the button the same height as the parameter fields above it.
+    m_button->SetStyle(ButtonStyle::Regular, ButtonType::Parameter);
+
+    wxSize size(def_width_wider() * m_em_unit, m_button->GetMinSize().GetHeight());
+    if (m_opt.height >= 0) size.SetHeight(m_opt.height * m_em_unit);
+    if (m_opt.width >= 0)  size.SetWidth(m_opt.width * m_em_unit);
+    m_button->SetMinSize(size);
+    m_button->SetSize(size);
+
+    m_button->Bind(wxEVT_BUTTON, [this](wxCommandEvent&) { open_dialog(); });
+    m_button->SetToolTip(get_tooltip_text(_L("Configure")));
+
+    window = m_button;
+
+    if (const ConfigOptionString* def = m_opt.get_default_value<ConfigOptionString>())
+        m_json = def->value;
+
+    update_button_label();
+    m_value = m_json;
+}
+
+void PluginConfigField::update_button_label()
+{
+    if (m_button == nullptr)
+        return;
+
+    const nlohmann::json entries = plugin_overrides_as_json(m_json);
+    const size_t         count   = entries.is_array() ? entries.size() : 0;
+
+    m_button->SetLabel(count == 0 ? _L("Configure")
+                                  : wxString::Format(_L("Configure (%d)"), int(count)));
+}
+
+void PluginConfigField::open_dialog()
+{
+    const Preset::Type type = static_cast<Preset::Type>(m_preset_type);
+    if (type != Preset::TYPE_PRINT && type != Preset::TYPE_FILAMENT && type != Preset::TYPE_PRINTER)
+        return;
+
+    std::string edited;
+    {
+        PluginsConfigDialog dlg(m_button, type, m_json);
+        dlg.ShowModal();
+        edited = dlg.overrides_json();
+    }
+
+    // Compare semantically: a round-trip through the serializer can reorder keys or drop whitespace,
+    // and that alone must not dirty the preset.
+    if (plugin_overrides_as_json(m_json) == plugin_overrides_as_json(edited))
+        return;
+
+    m_json  = edited;
+    m_value = m_json;
+    update_button_label();
+    on_change_field();
+}
+
+void PluginConfigField::set_value(const boost::any& value, bool change_event)
+{
+    m_disable_change_event = !change_event;
+
+    if (value.type() == typeid(wxString))
+        m_json = into_u8(boost::any_cast<wxString>(value));
+    else if (value.type() == typeid(std::string))
+        m_json = boost::any_cast<std::string>(value);
+
+    m_value = m_json;
+    update_button_label();
+
+    m_disable_change_event = false;
+}
+
+boost::any& PluginConfigField::get_value()
+{
+    // std::string, not wxString: change_opt_value any_casts a coString to std::string.
+    m_value = m_json;
+    return m_value;
+}
+
+void PluginConfigField::enable()
+{
+    if (m_button)
+        m_button->Enable();
+}
+
+void PluginConfigField::disable()
+{
+    if (m_button)
+        m_button->Disable();
+}
+
+void PluginConfigField::msw_rescale()
+{
+    Field::msw_rescale();
+    if (m_button == nullptr)
+        return;
+
+    m_button->SetStyle(ButtonStyle::Regular, ButtonType::Parameter);
+
+    wxSize size(def_width_wider() * m_em_unit, m_button->GetMinSize().GetHeight());
+    if (m_opt.height >= 0) size.SetHeight(m_opt.height * m_em_unit);
+    if (m_opt.width >= 0)  size.SetWidth(m_opt.width * m_em_unit);
+    m_button->SetMinSize(size);
+}
+
 void ColourPicker::BUILD()
 {
    auto size = wxSize(def_width_wider() * m_em_unit, -1); // ORCA match color picker width
--- a/src/slic3r/GUI/Field.hpp
+++ b/src/slic3r/GUI/Field.hpp
@@ -32,6 +32,9 @@
 #define wxMSW false
 #endif

+// Orca's styled button (Widgets/Button.hpp), used by PluginConfigField. It lives at global scope.
+class Button;
+
 namespace Slic3r { namespace GUI {

 class Field;
@@ -483,9 +486,8 @@ public:
    void enable() override;
    void disable() override;

-    // Window-field: the dynamic rows live inside a single container panel (assigned to the base
-    // `window` in BUILD), so the field exposes one window instead of a bare sizer. This lets focus/
-    // scroll, full-width sizing and teardown operate on the whole field.
+    // The rows live in one container panel (the base `window`), so the field exposes a window instead
+    // of a bare sizer and focus, sizing and teardown apply to the whole field.
    wxWindow* getWindow() override { return window; }

    void msw_rescale() override;
@@ -517,6 +519,45 @@ private:
    std::function<std::string()> m_selector;
 };

+// A settings row whose value is a raw JSON document nobody types by hand: the button opens
+// PluginsConfigDialog and the document it hands back becomes the field's value. The edit goes through
+// the ordinary Field value/on_change_field path, so the row gets the same dirty state and revert arrow
+// as any other setting — the dialog never touches the preset.
+class PluginConfigField : public Field {
+    using Field::Field;
+public:
+    PluginConfigField(const ConfigOptionDef& opt, const t_config_option_key& id) : Field(opt, id) {}
+    PluginConfigField(wxWindow* parent, const ConfigOptionDef& opt, const t_config_option_key& id) : Field(parent, opt, id) {}
+    ~PluginConfigField() {}
+
+    void BUILD() override;
+
+    // Which preset's capabilities the dialog lists; set by the option group. An int for the same
+    // reason OptionsGroup::m_config_type is one: it keeps Preset.hpp out of this header.
+    void set_preset_type(int type) { m_preset_type = type; }
+
+    void set_value(const boost::any& value, bool change_event = false) override;
+    boost::any& get_value() override;
+
+    void enable() override;
+    void disable() override;
+
+    // The button is the whole field, so it is the window the option group sizes and positions (the
+    // ColourPicker idiom). A container panel would be sized but never laid out, collapsing the row.
+    wxWindow* getWindow() override { return window; }
+
+    void msw_rescale() override;
+
+private:
+    void open_dialog();
+    void update_button_label();
+
+    wxWindow*   window { nullptr };  // == m_button; the base class hands this to the option group
+    ::Button*   m_button { nullptr };
+    std::string m_json;              // the option's raw text; "" when the preset overrides nothing
+    int         m_preset_type { -1 };
+};
+
 class ColourPicker : public Field {
 	using Field::Field;

--- a/src/slic3r/GUI/OptionsGroup.cpp
+++ b/src/slic3r/GUI/OptionsGroup.cpp
@@ -53,6 +53,7 @@ const t_field& OptionsGroup::build_field(const t_config_option_key& id, const Co
        break;
    case ConfigOptionDef::GUIType::one_string: m_fields.emplace(id, TextCtrl::Create<TextCtrl>(this->ctrl_parent(), opt, id)); break;
    case ConfigOptionDef::GUIType::plugin_picker: m_fields.emplace(id, PluginField::Create<PluginField>(this->ctrl_parent(), opt, id)); break;
+    case ConfigOptionDef::GUIType::plugin_config: m_fields.emplace(id, PluginConfigField::Create<PluginConfigField>(this->ctrl_parent(), opt, id)); break;
    default:
        switch (opt.type) {
            case coFloatOrPercent:
@@ -126,6 +127,12 @@ const t_field& OptionsGroup::build_field(const t_config_option_key& id, const Co
        });
    }

+    // The dialog behind the button edits one preset's overrides, so it has to know which preset. Set
+    // here because fields are built lazily on activate() — too late for the Tab to reach in afterwards.
+    if (auto plugin_config_field = dynamic_cast<PluginConfigField*>(field.get()))
+        if (auto config_group = dynamic_cast<ConfigOptionsGroup*>(this))
+            plugin_config_field->set_preset_type(config_group->config_type());
+
    // assign function objects for callbacks, etc.
    return field;
 }
@@ -714,9 +721,8 @@ std::string OptionsGroup::pick_plugin(const ConfigOptionDef& opt)
    if (selection.plugin_key.empty() || selection.name.empty())
        return {};

-    // Validate that the selected capability's plugin is resolvable, but only the bare capability
-    // name is stored in the option; the full "name;uuid;capability" reference is derived lazily
-    // when the preset is serialized (see ConfigBase::save_plugin_collection).
+    // Only the bare capability name is stored; the full "name;uuid;capability" reference is derived when
+    // the preset is serialized (see ConfigBase::save_plugin_collection). Resolve here to reject bad picks.
    Slic3r::PluginDescriptor descriptor;
    if (!manager.try_get_plugin_descriptor(selection.plugin_key, descriptor) || descriptor.name.empty())
        return {};
--- a/src/slic3r/GUI/PluginsConfigDialog.cpp
+++ b/src/slic3r/GUI/PluginsConfigDialog.cpp
@@ -0,0 +1,221 @@
+#include "PluginsConfigDialog.hpp"
+
+#include "GUI_App.hpp"
+#include "I18N.hpp"
+#include "format.hpp"
+
+#include <libslic3r/Preset.hpp>
+#include <libslic3r/PresetBundle.hpp>
+#include <slic3r/plugin/PluginConfig.hpp>
+#include <slic3r/plugin/PluginManager.hpp>
+#include <slic3r/plugin/PluginResolver.hpp>
+#include <slic3r/plugin/PythonInterpreter.hpp>
+
+#include <boost/log/trivial.hpp>
+
+namespace Slic3r { namespace GUI {
+
+namespace {
+
+wxString preset_type_title(Preset::Type type)
+{
+    switch (type) {
+    case Preset::TYPE_PRINT: return _L("Process plugins");
+    case Preset::TYPE_FILAMENT: return _L("Filament plugins");
+    case Preset::TYPE_PRINTER: return _L("Printer plugins");
+    default: return _L("Plugins");
+    }
+}
+
+} // namespace
+
+PluginsConfigDialog::PluginsConfigDialog(wxWindow* parent, Preset::Type type, const std::string& overrides_json)
+    : WebViewHostDialog(parent, wxID_ANY, preset_type_title(type))
+    , m_type(type)
+{
+    // On failure the document stays empty and every row goes read-only (see m_parse_error), so a preset
+    // we cannot understand is never silently overwritten.
+    if (!parse_plugin_overrides(overrides_json, m_overrides, m_parse_error))
+        BOOST_LOG_TRIVIAL(error) << "Plugins Config dialog: " << m_parse_error;
+
+    create_webview("web/dialog/PluginsConfigDialog/index.html", preset_type_title(type), wxSize(820, 660),
+                   wxSize(640, 520));
+}
+
+PluginsConfigDialog::~PluginsConfigDialog() { m_alive->store(false, std::memory_order_release); }
+
+const Preset* PluginsConfigDialog::current_preset() const
+{
+    const PresetBundle* bundle = wxGetApp().preset_bundle;
+    if (bundle == nullptr)
+        return nullptr;
+
+    switch (m_type) {
+    case Preset::TYPE_PRINT: return &bundle->prints.get_edited_preset();
+    case Preset::TYPE_PRINTER: return &bundle->printers.get_edited_preset();
+    case Preset::TYPE_FILAMENT: return &bundle->filaments.get_edited_preset();
+    default: return nullptr;
+    }
+}
+
+PluginCapabilityId PluginsConfigDialog::identifier_from(const nlohmann::json& payload) const
+{
+    return {plugin_capability_type_from_string(payload.value("capability_type", "")),
+            payload.value("capability_name", ""),
+            payload.value("plugin_key", "")};
+}
+
+void PluginsConfigDialog::on_script_message(const nlohmann::json& payload)
+{
+    if (handle_common_script_command(payload))
+        return;
+
+    // Defer command handling out of the webview script-message callback, exactly as PluginsDialog
+    // does: GTK and macOS deliver it synchronously inside the native webview callback, and window
+    // work on that stack is the crash class fixed in b779a7bfed/f2ccbfc8b5. remove_preset_override
+    // puts a modal message box on that stack, which is the same bug.
+    wxGetApp().CallAfter([this, alive = m_alive, payload]() {
+        if (alive->load(std::memory_order_acquire))
+            handle_web_command(payload);
+    });
+}
+
+void PluginsConfigDialog::handle_web_command(const nlohmann::json& payload)
+{
+    const std::string command = payload.value("command", "");
+    if (command == "request_capabilities") {
+        send_capabilities();
+        return;
+    }
+
+    const PluginCapabilityId id = identifier_from(payload);
+
+    if (command == "get_capability_config") {
+        send_capability_config(id);
+    } else if (command == "save_capability_config") {
+        if (!m_parse_error.empty()) {
+            send_save_error(id, m_parse_error);
+            return;
+        }
+
+        nlohmann::json value = payload.contains("config") ? payload.at("config") : nlohmann::json::object();
+        if (value.is_string()) {
+            value = nlohmann::json::parse(value.get<std::string>(), nullptr, /* allow_exceptions */ false);
+            if (value.is_discarded()) {
+                send_save_error(id, into_u8(_L("The configuration is not valid JSON. Your changes were not saved.")));
+                return;
+            }
+        }
+
+        const MutationResult result = m_service.set_preset_override(m_overrides, id, value);
+        if (!result.ok) {
+            send_save_error(id, result.error);
+            return;
+        }
+        send_capability_config(id);
+        show_status(_L("Configuration updated. Save the preset to persist it."), "success");
+    } else if (command == "remove_preset_override") {
+        // "Restore defaults" for a preset means holding no override at all: the capability falls back
+        // to the global configuration, not to the plugin's own get_default_config().
+        if (!m_parse_error.empty()) {
+            send_save_error(id, m_parse_error);
+            return;
+        }
+
+        const int rc = wxMessageBox(wxString::Format(_L("Restore the default configuration for \"%s\"?\n\n"
+                                                        "This discards the preset's override and uses the global configuration."),
+                                                     from_u8(id.name)),
+                                    _L("Restore defaults"), wxYES_NO | wxNO_DEFAULT | wxICON_WARNING, this);
+        if (rc != wxYES)
+            return;
+
+        const MutationResult result = m_service.remove_preset_override(m_overrides, id);
+        if (!result.ok) {
+            send_save_error(id, result.error);
+            return;
+        }
+        send_capability_config(id);
+        show_status(_L("Using global configuration. Save the preset to persist it."), "success");
+    }
+}
+
+void PluginsConfigDialog::send_capabilities()
+{
+    const Preset* preset = current_preset();
+    if (preset == nullptr)
+        return;
+
+    nlohmann::json response;
+    response["command"]     = "list_capabilities";
+    response["preset_type"] = static_cast<int>(m_type);
+    response["preset_name"] = preset->name;
+    response["data"]        = PluginConfig::capabilities_payload(capabilities_in_use(m_type, *preset));
+
+    BOOST_LOG_TRIVIAL(info) << "Prepared " << response["data"].size() << " capability rows for the Plugins Config dialog";
+    call_web_handler(response);
+}
+
+void PluginsConfigDialog::send_capability_config(const PluginCapabilityId& id)
+{
+    const Preset* preset = current_preset();
+
+    nlohmann::json response;
+    response["command"]         = "capability_config";
+    response["plugin_key"]      = id.plugin_key;
+    response["capability_name"] = id.name;
+    response["capability_type"] = plugin_capability_type_to_string(id.type);
+    response["config"]          = nlohmann::json::object();
+    response["custom_html"]     = "";
+    response["error"]           = "";
+
+    const auto cap = PluginManager::instance().get_plugin_capability(id, false);
+    if (!cap || preset == nullptr) {
+        response["error"] = into_u8(_L("This capability is no longer available."));
+        call_web_handler(response);
+        return;
+    }
+
+    const EffectiveCapabilityConfig effective = m_service.get_effective_config(m_overrides, id);
+    response["config"]                 = effective.config;
+    response["has_preset_override"]    = effective.has_preset_override;
+    response["has_base_config"]        = effective.has_base_config;
+    response["stored_plugin_version"]  = effective.stored_plugin_version;
+    response["running_plugin_version"] = effective.running_plugin_version;
+    response["read_only"]              = !m_parse_error.empty();
+    if (!m_parse_error.empty())
+        response["error"] = m_parse_error;
+
+    if (cap->config_ui_available()) {
+        try {
+            wxBusyCursor  busy;
+            PythonGILState gil;
+            response["custom_html"] = cap->get_config_ui();
+        } catch (const std::exception& ex) {
+            response["error"] = into_u8(GUI::format_wxstr(_L("The plugin's configuration UI failed to load (%1%). Showing the default editor."),
+                                                          from_u8(ex.what())));
+        }
+    }
+
+    call_web_handler(response);
+}
+
+void PluginsConfigDialog::send_save_error(const PluginCapabilityId& id, const std::string& error)
+{
+    call_web_handler({{"command", "capability_config_saved"},
+                      {"plugin_key", id.plugin_key},
+                      {"capability_name", id.name},
+                      {"capability_type", plugin_capability_type_to_string(id.type)},
+                      {"ok", false},
+                      {"error", error}});
+}
+
+void PluginsConfigDialog::show_status(const wxString& message, const char* level)
+{
+    nlohmann::json payload;
+    payload["command"] = "status_message";
+    payload["level"]   = level;
+    payload["message"] = into_u8(message);
+    call_web_handler(payload);
+}
+
+}} // namespace Slic3r::GUI
--- a/src/slic3r/GUI/PluginsConfigDialog.hpp
+++ b/src/slic3r/GUI/PluginsConfigDialog.hpp
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <slic3r/GUI/Widgets/WebViewHostDialog.hpp>
+#include <libslic3r/Preset.hpp>
+#include <slic3r/plugin/PluginConfig.hpp>
+
+#include <atomic>
+#include <memory>
+#include <string>
+
+namespace Slic3r { namespace GUI {
+
+// Lists the plugin capabilities the edited preset of `m_type` uses (see capabilities_in_use) and edits
+// each one's config, falling back to the global config where the preset has no override.
+//
+// A pure editor over a JSON document: it never writes to the preset and never writes to the base config
+// file. The caller seeds it with the preset's raw override text and reads the edited text back from
+// overrides_json(); PluginConfigField owns the value and feeds it through the normal field/dirty pipeline.
+class PluginsConfigDialog : public WebViewHostDialog
+{
+public:
+    PluginsConfigDialog(wxWindow* parent, Preset::Type type, const std::string& overrides_json);
+    ~PluginsConfigDialog() override;
+
+    // The edited overrides as compact JSON text; "" once no override remains.
+    std::string overrides_json() const { return serialize_plugin_overrides(m_overrides); }
+
+private:
+    void on_script_message(const nlohmann::json& payload) override;
+    // Runs one web command on a clean main-loop stack; see on_script_message.
+    void handle_web_command(const nlohmann::json& payload);
+
+    const Preset* current_preset() const;
+    void          send_capabilities();
+    void          send_capability_config(const PluginCapabilityId& id);
+    void          send_save_error(const PluginCapabilityId& id, const std::string& error);
+    void          show_status(const wxString& message, const char* level);
+
+    PluginCapabilityId identifier_from(const nlohmann::json& payload) const;
+
+    Preset::Type              m_type = Preset::TYPE_INVALID;
+    PresetPluginConfigService m_service;
+    // The working copy the dialog edits. Seeded from the preset's raw text, read back by the caller.
+    CapabilityConfigDocument  m_overrides;
+    // Set when the preset's stored text could not be parsed: the rows are shown read-only rather
+    // than silently replacing data we did not understand.
+    std::string               m_parse_error;
+    // Guards the deferred command handlers against the dialog being destroyed while one is queued.
+    std::shared_ptr<std::atomic<bool>> m_alive = std::make_shared<std::atomic<bool>>(true);
+};
+
+}} // namespace Slic3r::GUI
--- a/src/slic3r/GUI/PluginsDialog.cpp
+++ b/src/slic3r/GUI/PluginsDialog.cpp
@@ -4,6 +4,7 @@
 #include "GUI_App.hpp"
 #include "I18N.hpp"
 #include "OrcaCloudServiceAgent.hpp"
+#include "slic3r/plugin/PluginConfig.hpp"
 #include "slic3r/plugin/PluginFsUtils.hpp"
 #include "slic3r/plugin/PluginManager.hpp"

@@ -36,9 +37,9 @@
 namespace Slic3r { namespace GUI {
 namespace {

-const wxString kDeletePluginTitle    = _L("Delete Plugin");
-const wxString kUnsubscribeTitle     = _L("Unsubscribe");
-const wxString kOverwritePluginTitle = _L("Overwrite Plugin");
+const wxString kDeletePluginTitle            = _L("Delete Plugin");
+const wxString kUnsubscribeTitle             = _L("Unsubscribe");
+const wxString kOverwritePluginTitle         = _L("Overwrite Plugin");
 std::string s_selected_plugin_install_action = "explore";

 struct PluginContextAction
@@ -58,12 +59,13 @@ struct PluginAvailableActions

 struct PluginCapabilityView
 {
-    std::string name;
-    std::string type_label;
-    std::string type_key;
+    PluginCapabilityId id;
    bool enabled    = false;
    bool can_toggle = false;
    bool can_run    = false;
+    // Whether the capability supplies its own config UI; every capability is configurable, this only
+    // picks the editor. False for descriptor-only rows: an unloaded plugin has no capabilities yet.
+    bool has_config_ui = false;
 };

 struct PluginChangelogView
@@ -76,7 +78,6 @@ struct PluginChangelogView
 // View-model for one plugin row in the dialog
 struct PluginDialogItem
 {
-    // Identity and display text
    std::string plugin_key;
    std::string plugin_id;
    std::string display_name;
@@ -85,7 +86,7 @@ struct PluginDialogItem
    std::string version;
    std::string installed_version;
    std::string latest_version;
-    std::string sort_version;   // Version shown in the row (installed if installed, else latest); used by the Version sort.
+    std::string sort_version; // Version shown in the row (installed if installed, else latest); used by the Version sort.
    std::string type_label;
    std::string type_key;
    std::string sharing_token;
@@ -93,16 +94,14 @@ struct PluginDialogItem
    std::vector<std::string> type_labels;
    std::vector<PluginChangelogView> changelog;

-    // Derived UI state
    PluginSource source              = PluginSource::Local;
    PluginStatus status              = PluginStatus::Inactive;
    PluginUpdateStatus update_status = PluginUpdateStatus::Normal;
    std::string error_text;
    bool has_error = false;
-    bool is_loaded    = false;
+    bool is_loaded = false;
    bool loading   = false;

-    // Installation and capability flags
    bool is_cloud_plugin       = false;
    bool has_local_package     = false;
    bool unauthorized          = false;
@@ -112,7 +111,6 @@ struct PluginDialogItem
    // Runtime capabilities in registration order, or descriptor-only type rows when unloaded.
    std::vector<PluginCapabilityView> capabilities;

-    // Row-level actions
    PluginAvailableActions available_actions;
 };

@@ -172,15 +170,13 @@ void refresh_plugin_metadata_blocking(bool fetch_cloud)
            return;

        for (const auto& uuid : not_found)
-            plater->get_notification_manager()->push_notification(
-                NotificationType::CustomNotification,
-                NotificationManager::NotificationLevel::RegularNotificationLevel,
-                format(_L("Plugin %s is no longer available."), uuid));
+            plater->get_notification_manager()->push_notification(NotificationType::CustomNotification,
+                                                                  NotificationManager::NotificationLevel::RegularNotificationLevel,
+                                                                  format(_L("Plugin %s is no longer available."), uuid));
        for (const auto& uuid : unauthorized)
-            plater->get_notification_manager()->push_notification(
-                NotificationType::CustomNotification,
-                NotificationManager::NotificationLevel::RegularNotificationLevel,
-                format(_L("Plugin %s access is unauthorized."), uuid));
+            plater->get_notification_manager()->push_notification(NotificationType::CustomNotification,
+                                                                  NotificationManager::NotificationLevel::RegularNotificationLevel,
+                                                                  format(_L("Plugin %s access is unauthorized."), uuid));
    });
 }

@@ -203,16 +199,26 @@ nlohmann::json build_plugin_payload_item(const PluginDialogItem& dialog_item)
    nlohmann::json caps = nlohmann::json::array();
    for (const PluginCapabilityView& capability : dialog_item.capabilities) {
        nlohmann::json c;
-        c["name"]       = capability.name;
-        c["type"]       = capability.type_label;
-        c["type_key"]   = capability.type_key;
-        c["enabled"]    = capability.enabled;
-        c["can_toggle"] = capability.can_toggle;
-        c["can_run"]    = capability.can_run;
+        c["name"]          = capability.id.name;
+        c["type"]          = plugin_capability_type_display_name(capability.id.type);
+        c["type_key"]      = plugin_capability_type_to_string(capability.id.type);
+        c["enabled"]       = capability.enabled;
+        c["can_toggle"]    = capability.can_toggle;
+        c["can_run"]       = capability.can_run;
+        c["has_config_ui"] = capability.has_config_ui;
        caps.push_back(std::move(c));
    }
    payload_item["capabilities"] = std::move(caps);

+    // The Config tab's sidebar, built by the shared builder so it stays identical to PluginsConfigDialog's.
+    // Not the `capabilities` array above: that is the list tab's, with enable/run state and descriptor-only
+    // rows the config view has no use for.
+    std::vector<PluginCapabilityId> config_ids;
+    for (const PluginCapabilityView& capability : dialog_item.capabilities)
+        if (!capability.id.name.empty())
+            config_ids.push_back(capability.id);
+    payload_item["config_capabilities"] = PluginConfig::capabilities_payload(config_ids);
+
    nlohmann::json changelog = nlohmann::json::array();
    for (const PluginChangelogView& entry : dialog_item.changelog) {
        nlohmann::json c;
@@ -304,31 +310,28 @@ PluginDialogItem build_plugin_dialog_item(const PluginDescriptor& descriptor)
    PluginDialogItem item;
    PluginManager& manager = PluginManager::instance();

-    item.plugin_key        = descriptor.plugin_key;
-    item.display_name      = descriptor.name;
-    item.description       = !descriptor.is_metadata_valid() && descriptor.has_error() ?
-                                 descriptor.normalized_error() :
-                                 (descriptor.description.empty() ? "No description." : descriptor.description);
-    item.author            = descriptor.author;
-    item.version           = descriptor.version;
-    // Installed version: the cloud merge overwrites `version` with the latest cloud version, so prefer
-    // the preserved local version, falling back to `version` for local-only / pre-merge descriptors.
+    item.plugin_key   = descriptor.plugin_key;
+    item.display_name = descriptor.name;
+    item.description  = !descriptor.is_metadata_valid() && descriptor.has_error() ?
+                            descriptor.normalized_error() :
+                            (descriptor.description.empty() ? "No description." : descriptor.description);
+    item.author       = descriptor.author;
+    item.version      = descriptor.version;
+    // The cloud merge overwrites `version` with the latest cloud version, so prefer the preserved local
+    // one, falling back to `version` for local-only / pre-merge descriptors.
    item.installed_version = descriptor.has_local_package() ?
                                 (descriptor.installed_version.empty() ? descriptor.version : descriptor.installed_version) :
                                 std::string{};
    item.latest_version    = descriptor.latest_available_version();
-    // why: sort by the same version the row displays (GetDisplayVersion in index.js) - installed when
-    //   installed, otherwise latest - so the Version sort matches what the user sees.
    item.sort_version      = item.installed_version.empty() ? item.latest_version : item.installed_version;
    // A package that is not loaded has no capabilities, so its row contributes none and does not
    // expand.
    const std::vector<std::shared_ptr<PluginCapabilityInterface>> capabilities =
        manager.get_plugin_capabilities(descriptor.plugin_key, PluginCapabilityType::Unknown, /*only_enabled=*/false);

-    const PluginCapabilityType primary_type = capabilities.empty() ? PluginCapabilityType::Unknown :
-                                                                     capabilities.front()->type();
-    item.type_label        = plugin_capability_type_to_string(primary_type);
-    item.type_key          = plugin_capability_type_to_string(primary_type);
+    const PluginCapabilityType primary_type = capabilities.empty() ? PluginCapabilityType::Unknown : capabilities.front()->type();
+    item.type_label                         = plugin_capability_type_to_string(primary_type);
+    item.type_key                           = plugin_capability_type_to_string(primary_type);
    // "types" is the display-only compatibility list. Cloud plugins show the raw labels the
    // service returned (which may not map to real capability types); local plugins derive them
    // from the capabilities actually loaded.
@@ -356,8 +359,7 @@ PluginDialogItem build_plugin_dialog_item(const PluginDescriptor& descriptor)
    item.loading               = manager.is_plugin_load_in_progress(descriptor.plugin_key);
    item.has_script_capability = false;
    for (const auto& capability : capabilities) {
-        item.capabilities.push_back({capability->name(), plugin_capability_type_display_name(capability->type()),
-                                     plugin_capability_type_to_string(capability->type()), capability->is_enabled(), true, false});
+        item.capabilities.push_back({capability->identity(), capability->is_enabled(), true, false, capability->config_ui_available()});
        if (capability->type() == PluginCapabilityType::Script)
            item.has_script_capability = true;
    }
@@ -376,12 +378,12 @@ PluginDialogItem build_plugin_dialog_item(const PluginDescriptor& descriptor)
    item.available_actions        = evaluate_action_policy(item);
    const bool has_enabled_script = std::any_of(item.capabilities.begin(), item.capabilities.end(),
                                                [](const PluginCapabilityView& capability) {
-                                                    return capability.type_key == "script" && capability.enabled;
+                                                    return capability.id.type == PluginCapabilityType::Script && capability.enabled;
                                                });
    item.can_run_script = descriptor.is_metadata_valid() && !descriptor.has_error() && item.has_script_capability && item.is_loaded &&
                          !item.loading && has_enabled_script;
    for (PluginCapabilityView& capability : item.capabilities) {
-        capability.can_run = item.can_run_script && capability.type_key == "script" && capability.enabled;
+        capability.can_run = item.can_run_script && capability.id.type == PluginCapabilityType::Script && capability.enabled;
    }
    return item;
 }
@@ -479,8 +481,9 @@ void PluginsDialog::on_script_message(const nlohmann::json& payload)
    // Defer command handling out of the webview script-message callback: GTK and macOS
    // deliver it synchronously inside the native webview callback (see ui_create_window
    // in PluginHostUi.cpp), and window work on that stack is the crash class fixed in
-    // b779a7bfed/f2ccbfc8b5. Deferring at this single entry point keeps every command
-    // handler, current and future, off that stack by construction.
+    // b779a7bfed/f2ccbfc8b5. Deferring here keeps every command handler in THIS dialog off
+    // that stack; it is not a guarantee for other WebViewHostDialog subclasses, which each
+    // have to defer for themselves (PluginsConfigDialog does; others still do not).
    wxGetApp().CallAfter([this, alive = m_alive, payload]() {
        if (alive->load(std::memory_order_acquire))
            handle_web_command(payload);
@@ -515,6 +518,21 @@ void PluginsDialog::handle_web_command(const nlohmann::json& payload)
        open_plugin_hub();
    } else if (command == "set_plugin_sort") {
        set_plugin_sort(payload.value("sort_key", ""), payload.value("sort_order", ""));
+    } else if (command == "get_capability_config" || command == "save_capability_config" || command == "restore_capability_config") {
+        const PluginCapabilityId id{plugin_capability_type_from_string(payload.value("capability_type", "")),
+                                    payload.value("capability_name", ""), payload.value("plugin_key", "")};
+        if (command == "get_capability_config") {
+            send_capability_config(id);
+            return;
+        }
+        if (command == "restore_capability_config") {
+            restore_capability_config(id);
+            return;
+        }
+
+        // `config` is a JSON string from the default editor's textarea, or an already-structured
+        // value from a capability's custom UI. Both land here; save_capability_config sorts it out.
+        save_capability_config(id, payload.contains("config") ? payload.at("config") : nlohmann::json::object());
    } else if (command == "set_plugin_install_action") {
        const std::string action = payload.value("action", "");
        if (action == "explore" || action == "install-local")
@@ -549,7 +567,6 @@ nlohmann::json PluginsDialog::build_plugins_payload() const
    for (const PluginDescriptor& row : rows)
        items.push_back(build_plugin_dialog_item(row));

-    // In-place sort
    sort_plugin_items_for_dialog(items, m_plugin_sort_key, m_plugin_sort_order);

    for (const PluginDialogItem& item : items)
@@ -566,15 +583,6 @@ bool PluginsDialog::get_descriptor(const std::string& plugin_key, PluginDescript
    return manager.try_get_plugin_descriptor(plugin_key, descriptor) && descriptor.is_invalid_package();
 }

-std::shared_ptr<PluginCapabilityInterface> PluginsDialog::get_capability(const std::string& plugin_key,
-                                                                          PluginCapabilityType type,
-                                                                          const std::string& capability_name) const
-{
-    // only_enabled=false: this is an existence check used to gate both enabling and disabling a
-    // capability from the dialog, so a currently-disabled capability must still resolve.
-    return PluginManager::instance().get_plugin_capability(plugin_key, capability_name, type, /*only_enabled=*/false);
-}
-
 void PluginsDialog::refresh_plugin_metadata_async(const wxString& title, const wxString& message, bool fetch_cloud)
 {
    run_with_dialog([fetch_cloud]() { refresh_plugin_metadata_blocking(fetch_cloud); }, [this]() { send_plugins(); }, title, message);
@@ -639,8 +647,7 @@ void PluginsDialog::toggle_plugin(const std::string& plugin_key, bool enabled)
        }

        BOOST_LOG_TRIVIAL(info) << "Cloud plugin installed locally from Plugins dialog: " << plugin_key;
-        // download_and_install_cloud_plugin updates the descriptor with the installed
-        // local package state, so no rescan or cloud fetch is needed before loading.
+        // download_and_install_cloud_plugin already updated the descriptor, so no rescan is needed here.
        if (!get_descriptor(plugin_key, row_data)) {
            send_plugins();
            return;
@@ -678,8 +685,10 @@ void PluginsDialog::toggle_plugin(const std::string& plugin_key, bool enabled)
    show_status(wxString::Format(_L("Activating \"%s\"..."), plugin_display_name(plugin_key)), "info");
 }

-void PluginsDialog::toggle_plugin_capability(const std::string& plugin_key, PluginCapabilityType type,
-                                             const std::string& capability_name, bool enabled)
+void PluginsDialog::toggle_plugin_capability(const std::string& plugin_key,
+                                             PluginCapabilityType type,
+                                             const std::string& capability_name,
+                                             bool enabled)
 {
    if (plugin_key.empty() || capability_name.empty() || type == PluginCapabilityType::Unknown)
        return;
@@ -690,7 +699,7 @@ void PluginsDialog::toggle_plugin_capability(const std::string& plugin_key, Plug
        return;
    }

-    if (!get_capability(plugin_key, type, capability_name)) {
+    if (!PluginManager::instance().get_plugin_capability({type, capability_name, plugin_key}, /*only_enabled=*/false)) {
        BOOST_LOG_TRIVIAL(warning) << "Cannot toggle missing plugin capability: " << plugin_key << " | " << capability_name;
        send_plugins();
        return;
@@ -699,11 +708,11 @@ void PluginsDialog::toggle_plugin_capability(const std::string& plugin_key, Plug
    PluginManager& manager = PluginManager::instance();
    if (enabled) {
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Enabling plugin capability: " << plugin_key << " | " << capability_name;
-        manager.set_capability_enabled(plugin_key, capability_name, true);
+        manager.set_capability_enabled({type, capability_name, plugin_key}, true);
    } else {
        // check if the capability is currently in use here.
        BOOST_LOG_TRIVIAL(info) << __FUNCTION__ << ": Disabling plugin capability: " << plugin_key << " | " << capability_name;
-        manager.set_capability_enabled(plugin_key, capability_name, false);
+        manager.set_capability_enabled({type, capability_name, plugin_key}, false);
    }

    send_plugins();
@@ -892,6 +901,35 @@ wxString PluginsDialog::plugin_display_name(const std::string& plugin_key) const
    return from_u8(plugin_key);
 }

+void PluginsDialog::send_capability_config(const PluginCapabilityId& id) { call_web_handler(PluginConfig::get_config_response(id)); }
+
+void PluginsDialog::save_capability_config(const PluginCapabilityId& id, const nlohmann::json& config)
+{
+    const nlohmann::json response = PluginConfig::save_config_response(id, config);
+    call_web_handler(response);
+
+    if (response.value("ok", false))
+        show_status(_L("Configuration saved."), "success");
+}
+
+void PluginsDialog::restore_capability_config(const PluginCapabilityId& id)
+{
+    // Destructive, so confirm first. The confirmation stays here rather than in PluginConfig: it needs
+    // a parent window.
+    const int rc = wxMessageBox(wxString::Format(_L("Restore the default configuration for \"%s\"?\n\n"
+                                                    "This discards the settings currently saved for this capability."),
+                                                 from_u8(id.name)),
+                                _L("Restore defaults"), wxYES_NO | wxNO_DEFAULT | wxICON_WARNING, this);
+    if (rc != wxYES)
+        return;
+
+    const nlohmann::json response = PluginConfig::restore_config_response(id);
+    call_web_handler(response);
+
+    if (response.value("ok", false))
+        show_status(_L("Default configuration restored."), "success");
+}
+
 void PluginsDialog::run_script_plugin_capability(const std::string& plugin_key, const std::string& capability_name)
 {
    PluginManager& manager = PluginManager::instance();
@@ -909,8 +947,8 @@ void PluginsDialog::run_script_plugin_capability(const std::string& plugin_key,

        send_plugins();

-        // The row now shows an "Error" status and the Diagnostics tab holds the full text, so surface
-        // the outcome in the footer status bar instead of a modal box (prefer the friendlier override).
+        // The row already shows "Error" and the Diagnostics tab holds the full text, so report in the
+        // footer status bar instead of a modal box.
        const wxString message = status_message.empty() ? from_u8(normalized_error) : status_message;
        show_status(message, "error");
    };
@@ -936,6 +974,11 @@ void PluginsDialog::run_script_plugin_capability(const std::string& plugin_key,

    manager.clear_plugin_error(plugin_key);
    send_plugins();
+
+    const bool     skipped  = result.status == PluginResult::Skipped;
+    const wxString fallback = skipped ? _L("Script plugin skipped.") : _L("Script plugin finished.");
+    const wxString message  = result.message.empty() ? fallback : from_u8(result.message);
+    show_status(message, skipped ? "info" : "success");
 }

 void PluginsDialog::update_plugin(const std::string& plugin_key)
@@ -948,15 +991,13 @@ void PluginsDialog::update_plugin(const std::string& plugin_key)
    PluginDescriptor descriptor;
    const wxString name = get_descriptor(plugin_key, descriptor) ? from_u8(descriptor.name) : from_u8(plugin_key);

-    // update_cloud_plugin unloads the old plugin, deletes its local package, then downloads and
-    // reinstalls the latest version. Each of those steps already runs off the main thread in the
-    // delete/install paths, so run the whole operation on the worker and pump a progress dialog.
+    // update_cloud_plugin unloads the old plugin, deletes its local package and reinstalls the latest
+    // version; all of that is off-main-thread work, so run it on the worker behind a progress dialog.
    std::string error;
    bool updated = false;
    try {
-        updated = run_with_dialog_wait(
-            [plugin_key, &error]() { return PluginManager::instance().update_cloud_plugin(plugin_key, error); },
-            _L("Updating plugin"), _L("Updating") + ": " + name);
+        updated = run_with_dialog_wait([plugin_key, &error]() { return PluginManager::instance().update_cloud_plugin(plugin_key, error); },
+                                       _L("Updating plugin"), _L("Updating") + ": " + name);
    } catch (const std::exception& ex) {
        error = ex.what();
    } catch (...) {
@@ -970,8 +1011,7 @@ void PluginsDialog::update_plugin(const std::string& plugin_key)
        return;
    }

-    // update_cloud_plugin installs the package and updates the in-memory descriptor
-    // (installed=true, update_available=false) on success.
+    // update_cloud_plugin already updated the in-memory descriptor, so a UI refresh is enough here.
    send_plugins();
    show_status(wxString::Format(_L("Updated \"%s\"."), name), "success");
 }
@@ -1099,8 +1139,7 @@ void PluginsDialog::reinstall_local_plugin(const std::string& plugin_key)

                manager.load_plugin(plugin_key, false);
                std::string error;
-                if (!manager.wait_for_plugin_load(plugin_key, std::chrono::minutes(5), error) ||
-                    !manager.is_plugin_loaded(plugin_key))
+                if (!manager.wait_for_plugin_load(plugin_key, std::chrono::minutes(5), error) || !manager.is_plugin_loaded(plugin_key))
                    return {false, error.empty() ? "Plugin failed to load." : error};

                if (!was_loaded && !manager.unload_plugin(plugin_key))
@@ -1132,7 +1171,7 @@ void PluginsDialog::reinstall_cloud_plugin(const PluginDescriptor& plugin)
        return;

    PluginManager& manager = PluginManager::instance();
-    const bool was_loaded = PluginManager::instance().is_plugin_loaded(plugin_key);
+    const bool was_loaded  = PluginManager::instance().is_plugin_loaded(plugin_key);

    std::string error;
    if (plugin.has_local_package()) {
@@ -1158,8 +1197,7 @@ void PluginsDialog::reinstall_cloud_plugin(const PluginDescriptor& plugin)
                    PluginManager& manager = PluginManager::instance();
                    manager.load_plugin(plugin_key);
                    std::string error;
-                    if (!manager.wait_for_plugin_load(plugin_key, std::chrono::minutes(5), error) ||
-                        !manager.is_plugin_loaded(plugin_key))
+                    if (!manager.wait_for_plugin_load(plugin_key, std::chrono::minutes(5), error) || !manager.is_plugin_loaded(plugin_key))
                        return {false, error.empty() ? "Plugin failed to load." : error};
                    return {true, {}};
                },
--- a/src/slic3r/GUI/PluginsDialog.hpp
+++ b/src/slic3r/GUI/PluginsDialog.hpp
@@ -29,6 +29,7 @@ class wxTimer;
 namespace Slic3r {

 class PluginCapabilityInterface;
+struct PluginCapabilityId;
 enum class PluginCapabilityType;

 namespace GUI {
@@ -41,7 +42,7 @@ public:
                  const wxString& title = wxT(""),
                  const wxPoint& pos    = wxDefaultPosition,
                  const wxSize& size    = wxDefaultSize,
-                  long style            = wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxMAXIMIZE_BOX);
+                  long style            = wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxMAXIMIZE_BOX | wxRESIZE_BORDER);

    ~PluginsDialog();

@@ -65,7 +66,6 @@ private:
    nlohmann::json build_plugins_payload() const;

    bool get_descriptor(const std::string& plugin_key, Slic3r::PluginDescriptor& descriptor) const;
-    std::shared_ptr<PluginCapabilityInterface> get_capability(const std::string& plugin_key, PluginCapabilityType type, const std::string& capability_name) const;

    void refresh_plugin_metadata_async(const wxString& title, const wxString& message, bool fetch_cloud);
    void refresh_plugins();
@@ -77,6 +77,12 @@ private:
    bool install_plugin_package(const std::string& package_path);
    bool install_cloud_plugin(const std::string& uuid, const std::string& version, const wxString& name);
    void run_script_plugin_capability(const std::string& plugin_key, const std::string& capability_name);
+    // Config tab. Both are scoped to the full capability ID: a request naming a
+    // capability that is gone or not configurable is refused rather than served from, or written
+    // to, some other entry.
+    void send_capability_config(const PluginCapabilityId& id);
+    void save_capability_config(const PluginCapabilityId& id, const nlohmann::json& config);
+    void restore_capability_config(const PluginCapabilityId& id);
    // Pushes a one-line result into the web footer status bar (level: "success" | "warn" | "error" | "info"),
    // used for every plugin/capability operation instead of a modal box so the dialog stays non-disruptive.
    void show_status(const wxString& message, const char* level);
--- a/src/slic3r/GUI/PostProcessor.cpp
+++ b/src/slic3r/GUI/PostProcessor.cpp
@@ -270,10 +270,6 @@ static void run_post_process_plugins(const ConfigOptionStrings& capabilities,
        ctx.host         = host;
        ctx.output_name  = output_name;
        ctx.full_config  = &config;   // no live Print here; config_value() reads this
-        // Hand the plugin its own [tool.orcaslicer.plugin.settings] as ctx.params (same plugin_key the
-        // capability was resolved by), mirroring the in-pipeline dispatcher in GUI_App.cpp.
-        const std::string plugin_key = ref.uuid.empty() ? ref.name : ref.uuid;
-        ctx.params = PluginManager::instance().get_plugin_settings(plugin_key);

        ExecutionResult exec_result;
        try {
--- a/src/slic3r/GUI/Tab.cpp
+++ b/src/slic3r/GUI/Tab.cpp
@@ -1793,9 +1793,8 @@ void Tab::on_value_change(const std::string& opt_key, const boost::any& value)
        return;
    }

-    // Keep this preset's "plugins" manifest in sync when a plugin picker changes, so the edited preset
-    // always carries resolved "name;uuid;capability" references that full_config() and save_to_json()
-    // then pass downstream as-is -- no separate rebuild anywhere else.
+    // Keep this preset's "plugins" manifest in sync when a plugin picker changes, so full_config() and
+    // save_to_json() always find resolved "name;uuid;capability" references and rebuild it nowhere else.
    if (const ConfigOptionDef* opt_def = m_config->def()->get(opt_key);
        opt_def && opt_def->is_plugin_backed())
        m_config->update_plugin_manifest();
@@ -3123,6 +3122,11 @@ void TabPrint::build()
        option.opt.full_width = true;
        optgroup->append_single_option_line(option, "others_settings_plugin_picker");

+        // Its own group: the one above hides its labels, and this row needs its label — and the revert
+        // arrow beside it — to show. No label-width override either, as a 0 there means "no label column".
+        optgroup = page->new_optgroup(L("Plugin Configuration"), L"param_gcode");
+        optgroup->append_single_option_line("plugin_config_overrides");
+
        optgroup = page->new_optgroup(L("Notes"), "note", 0);
        option = optgroup->get_option("notes");
        option.opt.full_width = true;
@@ -4524,6 +4528,9 @@ void TabFilament::build()
        option.opt.height = gcode_field_height;// 150;
        optgroup->append_single_option_line(option);

+        optgroup = page->new_optgroup(L("Plugin Configuration"), L"param_gcode");
+        optgroup->append_single_option_line("plugin_config_overrides");
+
    page = add_options_page(L("Multimaterial"), "custom-gcode_multi_material"); // ORCA: icon only visible on placeholders
        optgroup = page->new_optgroup(L("Wipe tower parameters"), "param_tower");
        optgroup->append_single_option_line("filament_minimal_purge_on_wipe_tower", "material_multimaterial#multimaterial-wipe-tower-parameters");
@@ -5030,6 +5037,9 @@ void TabPrinter::build_fff()
        // optgroup->append_single_option_line("spaghetti_detector");
        optgroup->append_single_option_line("time_cost", "printer_basic_information_advanced#time-cost");

+        optgroup = page->new_optgroup(L("Plugin Configuration"), L"param_gcode");
+        optgroup->append_single_option_line("plugin_config_overrides");
+
        optgroup  = page->new_optgroup(L("Cooling Fan"), "param_cooling_fan");
        Line line = Line{ L("Fan speed-up time"), optgroup->get_option("fan_speedup_time").opt.tooltip };
        line.label_path = "printer_basic_information_cooling_fan#fan-speed-up-time";
--- a/src/slic3r/GUI/Widgets/WebViewHostDialog.hpp
+++ b/src/slic3r/GUI/Widgets/WebViewHostDialog.hpp
@@ -21,7 +21,9 @@ public:
                      const wxString& title = wxT(""),
                      const wxPoint& pos    = wxDefaultPosition,
                      const wxSize& size    = wxDefaultSize,
-                      long style            = wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxMAXIMIZE_BOX);
+                      // wxRESIZE_BORDER is required for a resizable frame on MSW/GTK; macOS derives
+                      // one from wxMAXIMIZE_BOX alone, which is why these dialogs used to resize only there.
+                      long style            = wxSYSTEM_MENU | wxCAPTION | wxCLOSE_BOX | wxMAXIMIZE_BOX | wxRESIZE_BORDER);
    ~WebViewHostDialog() override = default;

    bool create_webview(const std::string& resource_path,