Fix crash when importing a device with embedded samples

- The importer streamed the settings file in one pass, so a Sampler tried to
  load its nahd:// samples before the embedded <Data> blocks (which follow
  the <Device> element in the file) had been extracted. The unresolved path
  failed to open and loadSample threw across the QML boundary, crashing the
  app. This only happened without a project loaded first, since loading a
  project already populates the extracted-data map.

- Extract embedded data before deserializing the device, mirroring the
  project load path, and guard device deserialization so a failed sample
  load fails gracefully instead of crashing. Add a regression test with a
  reader that rejects unresolved nahd:// paths.

Author: juzzlin

CHANGELOG

@@ -40,6 +40,11 @@ New features:
 
 Bug fixes:
 
+* Fix crash when importing a device with embedded samples
+  - Embedded data is now extracted before the device is deserialized, so a
+    Sampler can resolve its sample paths while loading
+  - A failed sample load during import now fails gracefully instead of crashing
+
 * Fix rack Delay effect mode selector (Mono/Ping Pong/Tape had no effect)
 
 * Fix rack Delay effect manual (non-sync) time knob clamping at ~11 ms

src/application/service/device_service.cpp

@@ -596,7 +596,22 @@ bool DeviceService::importDeviceSettings(int slotIndex, const QString & filePath
     if (!file.open(QIODevice::ReadOnly)) {
         return false;
     }
-    NahdXmlReader reader { file };
+    const auto xml = QString::fromUtf8(file.readAll());
+
+    // Extract embedded data before deserializing the device so that a Sampler can resolve its
+    // nahd:// sample paths while loading. In the file the <Device> element precedes the <Data>
+    // blocks, so a single streaming pass would try to load samples before they are extracted.
+    // extractData() appends to the already-extracted data (it does not clear), so any embedded
+    // samples of a currently loaded project are preserved.
+    NahdXmlReader dataReader { xml };
+    while (!dataReader.atEnd()) {
+        if (dataReader.isStartElement() && dataReader.name() == Constants::NahdXml::xmlKeyData()) {
+            m_dataService->extractData(dataReader);
+        }
+        dataReader.readNext();
+    }
+
+    NahdXmlReader reader { xml };
     return importDeviceSettings(slotIndex, reader);
 }
 
@@ -629,8 +644,16 @@ bool DeviceService::importDeviceSettings(int slotIndex, ProjectReader & reader)
                         }
 
                         if (dev) {
-                            dev->deserializeFromXml(reader);
-                            dev->setId(static_cast<size_t>(slotIndex));
+                            try {
+                                dev->deserializeFromXml(reader);
+                                dev->setId(static_cast<size_t>(slotIndex));
+                            } catch (const std::exception & e) {
+                                // Deserialization can throw (e.g. a Sampler failing to load a sample). This is
+                                // invoked from QML, so swallow the exception here to fail gracefully instead of
+                                // crossing the C++/QML boundary and crashing.
+                                juzzlin::L(TAG).error() << std::format("Failed to import device settings: {}", e.what());
+                                return false;
+                            }
                         } else {
                             reader.skipCurrentElement();
                         }

src/unit_tests/device_service_test/device_service_test.cpp

@@ -110,6 +110,20 @@ class MockAudioFileReader : public AudioFileReader
     QByteArray m_writtenData;
 };
 
+// Simulates a real reader (e.g. SndFileReader) that cannot open an unresolved embedded path.
+// Used to prove that embedded data is extracted before samples are loaded during import.
+class NahdFailingMockAudioFileReader : public MockAudioFileReader
+{
+public:
+    bool open(const std::string & path, Mode mode, Info & info) override
+    {
+        if (QString::fromStdString(path).startsWith(Constants::NahdXml::embeddedDataPathPrefix())) {
+            return false;
+        }
+        return MockAudioFileReader::open(path, mode, info);
+    }
+};
+
 void DeviceServiceTest::initTestCase()
 {
     EffectFactory::init();
@@ -300,6 +314,52 @@ void DeviceServiceTest::test_exportImport_withEmbeddedData_shouldWork()
     QCOMPARE(resolvedFile.size(), 100 * 2 * sizeof(float));
 }
 
+void DeviceServiceTest::test_importDeviceSettings_embeddedData_emptySlot_shouldExtractDataBeforeLoadingSamples()
+{
+    // Export a Sampler with an embedded sample.
+    QTemporaryFile settingsFile;
+    QVERIFY(settingsFile.open());
+    const auto settingsPath = settingsFile.fileName();
+    settingsFile.close();
+
+    {
+        DeviceService service { std::make_shared<AudioEngine>(), std::make_shared<DataService>() };
+        auto sampler = std::make_shared<SamplerDevice>("TestSampler", std::make_unique<MockAudioFileReader>());
+        service.setDevice(0, sampler);
+
+        QTemporaryFile sampleFile { "test.wav" };
+        QVERIFY(sampleFile.open());
+        const auto samplePath = sampleFile.fileName();
+        sampleFile.write(QByteArray { 800, 0 });
+        sampleFile.close();
+
+        sampler->loadSample(60, samplePath.toStdString());
+        sampler->setEmbedWaveData(true);
+        QVERIFY(service.exportDeviceSettings(0, settingsPath));
+    }
+
+    // Import into a fresh service with an empty device rack (i.e. no project loaded first).
+    // The reader fails to open unresolved nahd:// paths, so if the embedded data were not
+    // extracted before the device is deserialized, the sample load would throw and import
+    // would fail. This reproduces the crash reported when importing without a loaded project.
+    const auto dataService = std::make_shared<DataService>();
+    DeviceService service { std::make_shared<AudioEngine>(), dataService };
+    service.setSamplerAudioFileReaderFactory([]() {
+        return std::make_unique<NahdFailingMockAudioFileReader>();
+    });
+
+    QVERIFY(!service.device(0)); // Empty slot
+    QVERIFY(service.importDeviceSettings(0, settingsPath));
+
+    const auto importedSampler = std::dynamic_pointer_cast<SamplerDevice>(service.device(0));
+    QVERIFY(importedSampler);
+    QVERIFY(importedSampler->sample(60));
+
+    const auto importedPath = QString::fromStdString(importedSampler->sample(60)->filePath);
+    QVERIFY(importedPath.startsWith(Constants::NahdXml::embeddedDataPathPrefix()));
+    QVERIFY(dataService->resolvePath(importedPath) != importedPath);
+}
+
 void DeviceServiceTest::test_peekDeviceTypeInfo_synth_shouldReturnCorrectTypeInfo()
 {
     const auto audioEngine = std::make_shared<AudioEngine>();

src/unit_tests/device_service_test/device_service_test.hpp

@@ -33,6 +33,7 @@ private slots:
     void test_importDeviceSettings_shouldReplaceDeviceIfTypeDiffers();
     void test_importDeviceSettings_emptySlot_shouldCreateDeviceFromFile();
     void test_exportImport_withEmbeddedData_shouldWork();
+    void test_importDeviceSettings_embeddedData_emptySlot_shouldExtractDataBeforeLoadingSamples();
     void test_peekDeviceTypeInfo_synth_shouldReturnCorrectTypeInfo();
     void test_peekDeviceTypeInfo_nonexistentFile_shouldReturnEmpty();
     void test_reverbSends_shouldSaveAndLoadCorrectly();