Revamp audio plugins module

src/converter/internal/compat/notationmeta.cpp

@@ -378,9 +378,9 @@ QJsonArray NotationMeta::tracksJsonArray(notation::INotationPtr notation)
         QJsonObject jsonTrack;
         jsonTrack.insert("instrumentId", trackId.instrumentId.toQString());
         jsonTrack.insert("partId", trackId.partId.toQString());
-        jsonTrack.insert("type", audioResourceTypeToString(inputParams.resourceMeta.type).toQString());
+        jsonTrack.insert("type", audio::audioResourceTypeToString(inputParams.resourceMeta.type).toQString());
 
-        audio::AudioSourceType sourceType = sourceTypeFromResourceType(inputParams.resourceMeta.type);
+        audio::AudioSourceType sourceType = audio::sourceTypeFromResourceType(inputParams.resourceMeta.type);
         if (sourceType != audio::AudioSourceType::Fluid) {
             if (sourceType == audio::AudioSourceType::MuseSampler) {
                 jsonTrack.insert("vendor", QString::fromStdString(inputParams.resourceMeta.attributeVal(

src/notationscene/qml/MuseScore/NotationScene/percussionpanel/percussionpanelmodel.cpp

@@ -553,7 +553,8 @@ void PercussionPanelModel::resetLayout()
     }
 
     const muse::audio::AudioResourceMeta& resourceMeta = audioSettings()->trackInputParams(currentTrackId()).resourceMeta;
-    const bool isMuseSamplerDrumset = resourceMeta.type == muse::audio::AudioResourceType::MuseSamplerSoundPack;
+    const bool isMuseSamplerDrumset = muse::audio::isResourceType(resourceMeta,
+                                                                  muse::audio::AudioResourceType::MuseSamplerSoundPack);
 
     Drumset defaultDrumset = isMuseSamplerDrumset ? museSamplerDefaultDrumset() : standardDefaultDrumset();
 
@@ -593,7 +594,7 @@ Drumset PercussionPanelModel::museSamplerDefaultDrumset() const
 
     const muse::audio::AudioResourceMeta& resourceMeta = audioSettings()->trackInputParams(currentTrackId()).resourceMeta;
 
-    const int instrumentId = resourceMeta.attributeVal(u"museUID").toInt();
+    const int instrumentId = muse::audio::intAttribute(resourceMeta, u"museUID");
 
     const muse::ByteArray drumMapping = museSampler()->drumMapping(instrumentId);
     IF_ASSERT_FAILED(!drumMapping.empty()) {

src/playback/CMakeLists.txt

@@ -42,6 +42,10 @@ target_sources(playback PRIVATE
     internal/soundprofilesrepository.h
     internal/drumsetloader.cpp
     internal/drumsetloader.h
+    internal/audiometabridge.cpp
+    internal/audiometabridge.h
+    internal/knownaudiopluginsconfigurator.cpp
+    internal/knownaudiopluginsconfigurator.h
 )
 
 if (MUE_BUILD_PLAYBACK_TESTS)

src/playback/internal/audiometabridge.cpp

@@ -0,0 +1,65 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2026 MuseScore Limited and others
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "audiometabridge.h"
+
+namespace mu::playback {
+muse::audio::AudioResourceMeta toAudioMeta(const muse::audioplugins::PluginMeta& meta)
+{
+    muse::audio::AudioResourceMeta out;
+    out.id = meta.id;
+    out.vendor = meta.vendor;
+    out.attributes = meta.attributes;
+    out.type = meta.type;
+    return out;
+}
+
+muse::audioplugins::PluginMeta toPluginMeta(const muse::audio::AudioResourceMeta& meta)
+{
+    muse::audioplugins::PluginMeta out;
+    out.id = meta.id;
+    out.vendor = meta.vendor;
+    out.attributes = meta.attributes;
+    out.type = meta.type;
+    return out;
+}
+
+muse::audio::AudioResourceMetaList toAudioMetaList(const muse::audioplugins::PluginMetaList& metas)
+{
+    muse::audio::AudioResourceMetaList out;
+    out.reserve(metas.size());
+    for (const auto& meta : metas) {
+        out.push_back(toAudioMeta(meta));
+    }
+    return out;
+}
+
+muse::audioplugins::PluginMetaList toPluginMetaList(const muse::audio::AudioResourceMetaList& metas)
+{
+    muse::audioplugins::PluginMetaList out;
+    out.reserve(metas.size());
+    for (const auto& meta : metas) {
+        out.push_back(toPluginMeta(meta));
+    }
+    return out;
+}
+}

src/playback/internal/audiometabridge.h

@@ -0,0 +1,39 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2026 MuseScore Limited and others
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "audio/common/audiotypes.h"
+#include "audioplugins/audiopluginstypes.h"
+
+// App-side bridge between audio::AudioResourceMeta (engine-domain) and
+// audioplugins::PluginMeta (cache-domain). The framework keeps the two
+// modules independent at the type/interface level; this is where MuseScore
+// converts between them at the natural seam - the playback controller, the
+// project audio settings, the sound profiles repository, etc.
+namespace mu::playback {
+muse::audio::AudioResourceMeta toAudioMeta(const muse::audioplugins::PluginMeta& meta);
+muse::audioplugins::PluginMeta toPluginMeta(const muse::audio::AudioResourceMeta& meta);
+
+muse::audio::AudioResourceMetaList toAudioMetaList(const muse::audioplugins::PluginMetaList& metas);
+muse::audioplugins::PluginMetaList toPluginMetaList(const muse::audio::AudioResourceMetaList& metas);
+}

src/playback/internal/drumsetloader.cpp

@@ -41,7 +41,7 @@ void DrumsetLoader::loadDrumset(INotationPtr notation, const InstrumentTrackId&
     }
 
     // restore the default drumset when changing from MuseSounds to MS Basic / VST
-    if (resourceMeta.type != AudioResourceType::MuseSamplerSoundPack) {
+    if (!isResourceType(resourceMeta, AudioResourceType::MuseSamplerSoundPack)) {
         const InstrumentTemplate& templ = instrumentsRepository()->instrumentTemplate(trackId.instrumentId);
         if (!templ.useDrumset) {
             return;
@@ -56,7 +56,7 @@ void DrumsetLoader::loadDrumset(INotationPtr notation, const InstrumentTrackId&
         return;
     }
 
-    int instrumentId = resourceMeta.attributeVal(u"museUID").toInt();
+    int instrumentId = muse::audio::intAttribute(resourceMeta, u"museUID");
 
     auto it = m_drumsetCache.find(instrumentId);
     if (it != m_drumsetCache.end()) {

src/playback/internal/knownaudiopluginsconfigurator.cpp

@@ -0,0 +1,81 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2026 MuseScore Limited and others
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#include "knownaudiopluginsconfigurator.h"
+
+#include "global/serialization/json.h"
+
+#include "audio/common/audiotypes.h"
+#include "mpe/playbacksetupdata.h"
+
+using namespace mu::playback;
+using namespace muse::audioplugins;
+
+void KnownAudioPluginsConfigurator::init()
+{
+    if (m_audioPluginConfiguration()) {
+        // MuseScore's audio engine routes synthesis via the playbackSetupData
+        // attribute. It is runtime-only — the engine re-injects the generic
+        // default at every load, so the cache file should not persist it.
+        PluginAttributes runtimeDefaults;
+        runtimeDefaults.emplace(muse::audio::PLAYBACK_SETUP_DATA_ATTRIBUTE,
+                                muse::mpe::GENERIC_SETUP_DATA_STRING);
+        m_audioPluginConfiguration()->setRuntimeAttributeDefaults(runtimeDefaults);
+    }
+
+    // MuseScore-specific audioplugins migrations only — framework-owned
+    // steps (v0->v1 structural, v1->v2 enabled->state) are pre-registered
+    // by the framework's AudioPluginsModule.
+    if (m_migrationRegister()) {
+        // v2 → v3: hasNativeEditorSupport moved from a top-level meta field
+        // into meta.attributes (string "true"/"false"). MuseScore-specific:
+        // audacity has no native-editor concept.
+        m_migrationRegister()->registerMigration(2, [](const muse::JsonArray& plugins) {
+            const std::string nativeEditorKey = muse::audio::HAS_NATIVE_EDITOR_SUPPORT_ATTRIBUTE.toStdString();
+            muse::JsonArray out;
+            for (size_t i = 0; i < plugins.size(); ++i) {
+                muse::JsonObject obj = plugins.at(i).toObject();
+                muse::JsonObject meta = obj.value("meta").toObject();
+                if (meta.contains(nativeEditorKey)) {
+                    muse::JsonObject attrs;
+                    if (meta.contains("attributes")) {
+                        attrs = meta.value("attributes").toObject();
+                    }
+                    const bool b = meta.value(nativeEditorKey).toBool();
+                    attrs.set(nativeEditorKey, b ? std::string("true") : std::string("false"));
+                    meta.set("attributes", attrs);
+
+                    // JsonObject has no remove(); rebuild without the legacy key.
+                    muse::JsonObject metaWithoutLegacy;
+                    for (const std::string& k : meta.keys()) {
+                        if (k == nativeEditorKey) {
+                            continue;
+                        }
+                        metaWithoutLegacy.set(k, meta.value(k));
+                    }
+                    obj.set("meta", metaWithoutLegacy);
+                }
+                out << obj;
+            }
+            return out;
+        });
+    }
+}

src/playback/internal/knownaudiopluginsconfigurator.h

@@ -0,0 +1,42 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2026 MuseScore Limited and others
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include "modularity/ioc.h"
+
+#include "audioplugins/iaudiopluginsconfiguration.h"
+#include "audioplugins/iknownaudiopluginsmigrationregister.h"
+
+namespace mu::playback {
+// MuseScore-specific configuration of the framework's shared known-audio-plugins
+// cache: marks runtime-only attributes and registers the app's cache migration.
+// Not a module — it's one-shot setup invoked from PlaybackModule::resolveImports()
+// (before the cache is loaded in the audioplugins context onInit).
+class KnownAudioPluginsConfigurator
+{
+    muse::GlobalInject<muse::audioplugins::IAudioPluginsConfiguration> m_audioPluginConfiguration;
+    muse::GlobalInject<muse::audioplugins::IKnownAudioPluginsMigrationRegister> m_migrationRegister;
+
+public:
+    void init();
+};
+}

src/playback/internal/playbackcontroller.cpp

@@ -493,7 +493,8 @@ bool PlaybackController::shouldLoadDrumset(const engraving::InstrumentTrackId& i
         return false;
     }
 
-    return oldMeta.type == AudioResourceType::MuseSamplerSoundPack || newMeta.type == AudioResourceType::MuseSamplerSoundPack;
+    return isResourceType(oldMeta, AudioResourceType::MuseSamplerSoundPack)
+           || isResourceType(newMeta, AudioResourceType::MuseSamplerSoundPack);
 }
 
 void PlaybackController::addSoundFlagsIfNeed(const std::vector<EngravingItem*>& selection)

src/playback/internal/soundprofilesrepository.cpp

@@ -67,11 +67,11 @@ void SoundProfilesRepository::refresh()
                 continue;
             }
 
-            if (resource.type == AudioResourceType::FluidSoundfont) {
+            if (isResourceType(resource, AudioResourceType::FluidSoundfont)) {
                 basicProfile.data.emplace(mpe::PlaybackSetupData::fromString(setup->second), resource);
             }
 
-            if (resource.type == AudioResourceType::MuseSamplerSoundPack) {
+            if (isResourceType(resource, AudioResourceType::MuseSamplerSoundPack)) {
                 museProfile.data.emplace(mpe::PlaybackSetupData::fromString(setup->second), resource);
             }
         }

src/playback/playbackmodule.cpp

@@ -33,6 +33,7 @@
 #include "internal/playbackcommands.h"
 #include "internal/playbackconfiguration.h"
 #include "internal/soundprofilesrepository.h"
+#include "internal/knownaudiopluginsconfigurator.h"
 
 using namespace mu::playback;
 using namespace muse;
@@ -64,6 +65,11 @@ void PlaybackModule::resolveImports()
     if (cr) {
         cr->reg(std::make_shared<PlaybackCommands>());
     }
+
+    // MuseScore-specific setup of the shared known-audio-plugins cache. Must run
+    // before the cache is loaded in the audioplugins context onInit — resolveImports
+    // of every module precedes any onInit, so this is the right phase.
+    KnownAudioPluginsConfigurator().init();
 }
 
 void PlaybackModule::onInit(const IApplication::RunMode&)