diff --git a/src/Main.cpp b/src/Main.cpp index 88521cd3f..7a04b6746 100644 --- a/src/Main.cpp +++ b/src/Main.cpp @@ -47,6 +47,7 @@ #include "NativeLogicalMixerControl.h" #include "PlayerSetlistArchive.h" #include "PlayerSetlistRepository.h" +#include "PlayerSetlistEditTransaction.h" #include "NativeHotkeyRegistry.h" #include "NativeHotkeyCommandPlan.h" #include "NativeFxParameterHotkey.h" @@ -57,6 +58,8 @@ #include "../engine/device/WindowsFirstRunEndpointDiscovery.h" #endif #include +#include +#include #include #include #include @@ -3939,6 +3942,23 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr else if(result==armix::player::PlayerSetlistRepository::SaveStatus::ioError) playerError_="Unable to save setlists; check folder permissions"; } + bool commitPlayerTrackEdit(std::vector nextFiles, + std::vector nextControls) { + using Edit=armix::player::PlayerSetlistEditTransaction; + auto outcome=Edit::replaceActiveTracks( + settingsDirectory().getChildFile("player-library.json"), + playerSets_,playerActiveSet_,nextFiles,nextControls, + playerAutoNext_,playerFadeMilliseconds_); + if(!outcome.committed()) { + playerError_=outcome.error; + return false; + } + // No accepted Player identity/queue/index change precedes disk commit. + playerSets_=std::move(outcome.sets); + playerLibrary_=std::move(nextFiles); + playerTrackSettings_=std::move(nextControls); + return true; + } bool playerShowMaySwitchSet() { const auto state=engine_.playerStatus().getProperty("state","").toString(); if(state=="PLAYING" || state=="PREPARING" || state=="PAUSED") { @@ -3948,61 +3968,38 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr return !playerFolderBusy_; } void playerEditSetlist(const juce::String& action,const juce::var& value) { + // Setlist metadata is durable BEFORE a deck stop or live state + // mutation. A failed disk write cannot switch/delete a live set. if(action=="playerNewSetlist" || action=="playerSelectSetlist" || - action=="playerDeleteSetlist") { - if(!playerShowMaySwitchSet())return; - if(action=="playerNewSetlist") { - if(playerSets_.size()>=32) { - playerError_="Maximum 32 setlists";emitPlayerState();return; - } - saveActivePlayerSet(); - const auto next=armix::player::PlayerSetlistArchive:: - nextGeneratedName(playerSets_); - if(next.isEmpty()) { - playerError_="No available setlist name"; - emitPlayerState();return; - } - playerSets_.push_back({next,{},{}}); - engine_.playerStop(); - activatePlayerSet(static_cast(playerSets_.size())-1); - } else { - const int index=static_cast(value); - if(index<0 || index>=static_cast(playerSets_.size()))return; - saveActivePlayerSet(); - if(action=="playerSelectSetlist") { - engine_.playerStop();activatePlayerSet(index); - } else if(playerSets_.size()>1) { - engine_.playerStop(); - int destination=playerActiveSet_; - if(index(playerSets_.size())-2); - playerSets_.erase(playerSets_.begin()+index); - activatePlayerSet(destination); - } else { - playerError_="Keep at least one setlist"; - emitPlayerState();return; - } + action=="playerDeleteSetlist" || action=="playerRenameSetlist") { + const bool rename=action=="playerRenameSetlist"; + if(!rename && !playerShowMaySwitchSet())return; + using Edit=armix::player::PlayerSetlistEditTransaction; + const auto command=action=="playerNewSetlist"?Edit::Command::create: + action=="playerSelectSetlist"?Edit::Command::select: + action=="playerDeleteSetlist"?Edit::Command::remove: + Edit::Command::rename; + const int index=rename || command==Edit::Command::create? + -1:static_cast(value); + // Preserve the historical silent no-op for stale row IDs. + if(!rename && command!=Edit::Command::create && + (index<0 || index>=static_cast(playerSets_.size())))return; + auto outcome=Edit::apply( + settingsDirectory().getChildFile("player-library.json"), + playerSets_,playerActiveSet_,playerLibrary_,playerTrackSettings_, + playerAutoNext_,playerFadeMilliseconds_,command,index, + rename?value.toString():juce::String{}); + if(!outcome.committed()) { + playerError_=outcome.error; + emitPlayerState(true);return; } - playerError_.clear();persistPlayerLibrary();emitPlayerState(true); - return; - } - if(action=="playerRenameSetlist") { - auto name=value.toString().trim(); - if(name.isEmpty() || name.length()>64)return; - const bool exists=std::any_of( - playerSets_.begin(),playerSets_.end(), - [&](const PlayerSavedSet& set) { - return set.name.equalsIgnoreCase(name) && - &set!=&playerSets_[static_cast(playerActiveSet_)]; - }); - if(exists) { - playerError_="Setlist name already exists"; - emitPlayerState();return; + playerSets_=std::move(outcome.sets); + if(!rename) { + engine_.playerStop(); + activatePlayerSet(outcome.active); } - playerSets_[static_cast(playerActiveSet_)].name=name; - playerError_.clear();persistPlayerLibrary();emitPlayerState(true); + playerError_.clear(); + emitPlayerState(true); return; } if(action=="playerMoveSong") { @@ -4015,7 +4012,12 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr items.erase(items.begin()+from); items.insert(items.begin()+to,std::move(item)); }; - move(playerLibrary_);move(playerTrackSettings_); + auto nextFiles=playerLibrary_; + auto nextControls=playerTrackSettings_; + move(nextFiles);move(nextControls); + if(!commitPlayerTrackEdit(std::move(nextFiles),std::move(nextControls))) { + emitPlayerState(true);return; + } const auto remap=[&](int index) { return armix::player::PlayerShowEditPolicy::afterMove( index,from,to,count); @@ -4023,7 +4025,7 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr playerSelected_=remap(playerSelected_); playerCurrent_=remap(playerCurrent_); playerPendingIndex_=remap(playerPendingIndex_); - persistPlayerLibrary();emitPlayerState(true); + playerError_.clear();emitPlayerState(true); return; } if(action=="playerRemoveSong") { @@ -4039,17 +4041,22 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr playerError_="Stop the playing song before removing it"; emitPlayerState();return; } - playerUndoRemove_={playerActiveSet_,index, - playerLibrary_[static_cast(index)], - playerTrackSettings_[static_cast(index)]}; + const auto removedFile=playerLibrary_[static_cast(index)]; + const auto removedControls=playerTrackSettings_[static_cast(index)]; + auto nextFiles=playerLibrary_; + auto nextControls=playerTrackSettings_; + nextFiles.erase(nextFiles.begin()+index); + nextControls.erase(nextControls.begin()+index); + if(!commitPlayerTrackEdit(std::move(nextFiles),std::move(nextControls))) { + emitPlayerState(true);return; + } + playerUndoRemove_={playerActiveSet_,index,removedFile,removedControls}; const auto queueCountBefore=playerQueue_.size(); playerQueue_.erase( std::remove(playerQueue_.begin(),playerQueue_.end(), playerUndoRemove_.file),playerQueue_.end()); if(queueCountBefore!=playerQueue_.size()) playerQueueEpoch_.changed(); - playerLibrary_.erase(playerLibrary_.begin()+index); - playerTrackSettings_.erase(playerTrackSettings_.begin()+index); const auto remap=[&](int old) { return armix::player::PlayerShowEditPolicy::afterRemove( old,index); @@ -4060,7 +4067,7 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr if(playerSelected_<0 && !playerLibrary_.empty()) playerSelected_=std::min(index, static_cast(playerLibrary_.size())-1); - playerError_.clear();persistPlayerLibrary();emitPlayerState(true); + playerError_.clear();emitPlayerState(true); return; } if(action=="playerUndoRemove") { @@ -4078,9 +4085,13 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr removed.file)!=playerLibrary_.end())return; const int index=std::clamp(removed.index,0, static_cast(playerLibrary_.size())); - playerLibrary_.insert(playerLibrary_.begin()+index,removed.file); - playerTrackSettings_.insert( - playerTrackSettings_.begin()+index,removed.controls); + auto nextFiles=playerLibrary_; + auto nextControls=playerTrackSettings_; + nextFiles.insert(nextFiles.begin()+index,removed.file); + nextControls.insert(nextControls.begin()+index,removed.controls); + if(!commitPlayerTrackEdit(std::move(nextFiles),std::move(nextControls))) { + emitPlayerState(true);return; + } playerCurrent_=armix::player::PlayerShowEditPolicy::afterInsert( playerCurrent_,index); playerSelected_=armix::player::PlayerShowEditPolicy::afterInsert( @@ -4088,7 +4099,7 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr playerPendingIndex_=armix::player::PlayerShowEditPolicy::afterInsert( playerPendingIndex_,index); playerUndoRemove_={}; - playerError_.clear();persistPlayerLibrary();emitPlayerState(true); + playerError_.clear();emitPlayerState(true); return; } if(action=="playerQueueNext" || action=="playerQueueAppend") { @@ -4227,29 +4238,37 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr (const juce::FileChooser& picker) { if(!safe)return; const auto files=picker.getResults(); + auto nextFiles=safe->playerLibrary_; + auto nextControls=safe->playerTrackSettings_; + // JUCE File order matches the native archive path identity; + // a 2,000-song import never needs quadratic scans. + std::map positions; + for(std::size_t i=0;i(-1); for(const auto& file:files) { if(!file.existsAsFile() || !file.hasFileExtension("wav;mp3;flac;aif;aiff;ogg")) continue; - const auto found=std::find(safe->playerLibrary_.begin(), - safe->playerLibrary_.end(),file); - if(found!=safe->playerLibrary_.end()) { + const auto known=positions.find(file); + if(known!=positions.end()) { if(first==static_cast(-1)) - first=static_cast( - found-safe->playerLibrary_.begin()); + first=known->second; continue; } - if(safe->playerLibrary_.size()>=2000)break; + if(nextFiles.size()>=2000)break; if(first==static_cast(-1)) - first=safe->playerLibrary_.size(); - safe->playerLibrary_.push_back(file); - safe->playerTrackSettings_.push_back({}); + first=nextFiles.size(); + positions.emplace(file,nextFiles.size()); + nextFiles.push_back(file); + nextControls.push_back({}); + } + if(safe->commitPlayerTrackEdit( + std::move(nextFiles),std::move(nextControls))) { + if(safe->playerSelected_<0 && first!=static_cast(-1)) + safe->playerSelected_=static_cast(first); + safe->playerError_.clear(); } - if(safe->playerSelected_<0 && first!=static_cast(-1)) - safe->playerSelected_=static_cast(first); - safe->playerError_.clear(); - safe->persistPlayerLibrary(); safe->emitPlayerState(true); // Do not destroy FileChooser inside its own callback. juce::MessageManager::callAsync([safe] { @@ -4294,36 +4313,39 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr relinks=std::move(relinks),initialLibrary]() mutable { if(!safe)return; safe->playerFolderBusy_=false; + auto nextFiles=safe->playerLibrary_; + auto nextControls=safe->playerTrackSettings_; + std::set known(nextFiles.begin(),nextFiles.end()); int added=0,relinked=0; - // Update only the exact rows the worker saw. - // Edits made during the scan must remain intact. + // Reconcile by exact row identity against the + // worker snapshot, without losing later live edits. for(const auto& change:relinks) { if(change.index>=initialLibrary.size() || - change.index>=safe->playerLibrary_.size() || + change.index>=nextFiles.size() || static_cast(change.index)==safe->playerCurrent_ || - safe->playerLibrary_[change.index]!= - initialLibrary[change.index] || - std::find(safe->playerLibrary_.begin(), - safe->playerLibrary_.end(), - change.replacement)!=safe->playerLibrary_.end()) + nextFiles[change.index]!=initialLibrary[change.index] || + known.contains(change.replacement)) continue; - safe->playerLibrary_[change.index]=change.replacement; - ++relinked; // keep stable IDs + KEY/TEMPO + known.erase(nextFiles[change.index]); + known.insert(change.replacement); + nextFiles[change.index]=change.replacement; + ++relinked; } int first=-1; for(const auto& file:scan.files) { - const auto found=std::find( - safe->playerLibrary_.begin(), - safe->playerLibrary_.end(),file); - if(found!=safe->playerLibrary_.end())continue; - if(safe->playerLibrary_.size()>= - armix::player::PlayerLibraryPolicy::maxSongs)break; - if(first<0) - first=static_cast(safe->playerLibrary_.size()); - safe->playerLibrary_.push_back(file); - safe->playerTrackSettings_.push_back({}); + if(known.contains(file))continue; + if(nextFiles.size()>=armix::player::PlayerLibraryPolicy::maxSongs) + break; + if(first<0)first=static_cast(nextFiles.size()); + known.insert(file); + nextFiles.push_back(file); + nextControls.push_back({}); ++added; } + if(!safe->commitPlayerTrackEdit( + std::move(nextFiles),std::move(nextControls))) { + safe->emitPlayerState(true);return; + } if(safe->playerSelected_<0 && first>=0) safe->playerSelected_=first; safe->playerError_=scan.truncated? @@ -4331,7 +4353,6 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr added==0 && relinked==0? "No new supported songs or safe missing-file matches found": juce::String{}; - safe->persistPlayerLibrary(); safe->emitPlayerState(true); }); }).detach(); @@ -4375,14 +4396,18 @@ class ConsoleWindow final : public juce::DocumentWindow, private juce::Timer, pr // Preserve same logical song ID, order and per-song // KEY/TEMPO. Never start a song or switch the output // as a side effect of locating a file. - if(safe->playerCurrent_==index) { - safe->engine_.playerStop(); - safe->playerCurrent_=-1; + auto nextFiles=safe->playerLibrary_; + auto nextControls=safe->playerTrackSettings_; + nextFiles[static_cast(index)]=chosen; + if(safe->commitPlayerTrackEdit( + std::move(nextFiles),std::move(nextControls))) { + if(safe->playerCurrent_==index) { + safe->engine_.playerStop(); + safe->playerCurrent_=-1; + } + safe->playerOutputPendingIndex_=-1; + safe->playerError_.clear(); } - safe->playerLibrary_[static_cast(index)]=chosen; - safe->playerOutputPendingIndex_=-1; - safe->playerError_.clear(); - safe->persistPlayerLibrary(); } safe->emitPlayerState(true); }); diff --git a/src/PlayerSetlistEditTransaction.h b/src/PlayerSetlistEditTransaction.h new file mode 100644 index 000000000..a158387ce --- /dev/null +++ b/src/PlayerSetlistEditTransaction.h @@ -0,0 +1,121 @@ +// SPDX-License-Identifier: AGPL-3.0-only +#pragma once +#include "PlayerSetlistRepository.h" +#include +#include +#include + +// N-MOD-16: durable-first setlist metadata use case, CONTROL thread only. +// Stage against the current live tracks, persist the complete validated v3 +// archive, then return a candidate to the one ConsoleWindow owner. No deck, +// PCM callback, WebView, UI acknowledgement, or other state is changed here. +namespace armix::player { +class PlayerSetlistEditTransaction final { +public: + enum class Command { create, select, remove, rename }; + using SaveStatus = PlayerSetlistRepository::SaveStatus; + struct Result { + SaveStatus status = SaveStatus::invalidState; + juce::String error; + std::vector sets; + int active = -1; + bool committed() const noexcept { + return status == SaveStatus::saved; + } + }; + + static Result apply(const juce::File& archive, + const std::vector& original, + int active, + const std::vector& liveFiles, + const std::vector& liveControls, + bool autoNext, int fadeMs, Command command, + int index = -1, const juce::String& proposedName = {}) { + if(original.empty() || active < 0 || + active >= static_cast(original.size()) || + liveFiles.size() != liveControls.size()) + return reject(SaveStatus::invalidState,"Unable to save setlists; invalid setlist state"); + + auto candidate = original; + candidate[static_cast(active)].files = liveFiles; + candidate[static_cast(active)].controls = liveControls; + int destination = active; + switch(command) { + case Command::create: { + if(candidate.size() >= 32) + return reject(SaveStatus::invalidState,"Maximum 32 setlists"); + auto name = PlayerSetlistArchive::nextGeneratedName(candidate); + if(name.isEmpty()) + return reject(SaveStatus::invalidState,"No available setlist name"); + candidate.push_back({std::move(name),{},{}}); + destination = static_cast(candidate.size()) - 1; + break; + } + case Command::select: + if(index < 0 || index >= static_cast(candidate.size())) + return reject(SaveStatus::invalidState,"Invalid setlist"); + destination = index; + break; + case Command::remove: + if(candidate.size() < 2) + return reject(SaveStatus::invalidState,"Keep at least one setlist"); + if(index < 0 || index >= static_cast(candidate.size())) + return reject(SaveStatus::invalidState,"Invalid setlist"); + if(index < active) + --destination; + else if(index == active) + destination = std::min(index,static_cast(candidate.size())-2); + candidate.erase(candidate.begin()+index); + break; + case Command::rename: { + const auto name = proposedName.trim(); + if(name.isEmpty() || name.length() > 64) + return reject(SaveStatus::invalidState,"Invalid setlist name"); + for(int i=0;i(candidate.size());++i) + if(i != active && candidate[static_cast(i)].name.equalsIgnoreCase(name)) + return reject(SaveStatus::invalidState,"Setlist name already exists"); + candidate[static_cast(active)].name = name; + break; + } + } + + return persist(archive,std::move(candidate),destination,autoNext,fadeMs); + } + + // Any validated active-song edit uses the same durable-before-adopt gate. + // Callers stage MOVE/REMOVE/UNDO/import/relink and adjust the deck/queue + // indices only after this returns a successfully stored candidate. + static Result replaceActiveTracks( + const juce::File& archive, + const std::vector& original,int active, + const std::vector& files, + const std::vector& controls, + bool autoNext,int fadeMs) { + if(original.empty() || active < 0 || + active >= static_cast(original.size()) || + files.size() != controls.size()) + return reject(SaveStatus::invalidState, + "Unable to save setlists; invalid setlist state"); + auto candidate=original; + auto& set=candidate[static_cast(active)]; + set.files=files; + set.controls=controls; + return persist(archive,std::move(candidate),active,autoNext,fadeMs); + } +private: + static Result persist(const juce::File& archive, + std::vector candidate,int active, + bool autoNext,int fadeMs) { + const auto stored=PlayerSetlistRepository::save( + archive,candidate,active,autoNext,fadeMs); + if(stored==SaveStatus::invalidState) + return reject(stored,"Unable to save setlists; invalid setlist state"); + if(stored==SaveStatus::ioError) + return reject(stored,"Unable to save setlists; check folder permissions"); + return {SaveStatus::saved,{},std::move(candidate),active}; + } + static Result reject(SaveStatus status,juce::String error) { + return {status,std::move(error),{},-1}; + } +}; +} // namespace armix::player diff --git a/tests/native_caption_wire_geometry_contract.test.cjs b/tests/native_caption_wire_geometry_contract.test.cjs index e1a879d30..862d57ae5 100644 --- a/tests/native_caption_wire_geometry_contract.test.cjs +++ b/tests/native_caption_wire_geometry_contract.test.cjs @@ -132,7 +132,14 @@ const playerHtml = read('site/preview-v2/assets/mixer-contextual-buttons.js'); const playerArchive = read('src/PlayerSetlistArchive.h'); assert.match(playerArchive, /struct PlayerTrackSettings/); assert.match(playerArchive, /nextGeneratedName/); -assert.match(main, /PlayerSetlistArchive::\s*nextGeneratedName/); +const playerEditTransaction=read('src/PlayerSetlistEditTransaction.h'); +assert.match(playerEditTransaction, /PlayerSetlistArchive::nextGeneratedName/); +assert.match(playerEditTransaction, /PlayerSetlistRepository::save/); +assert.match(main, /using Edit=armix::player::PlayerSetlistEditTransaction/); +assert.match(main, /auto outcome=Edit::apply/); +assert.match(playerEditTransaction, /replaceActiveTracks/); +assert.match(main, /commitPlayerTrackEdit/); +assert.match(main, /Edit::replaceActiveTracks/); assert.match(playerArchive, /static bool canUndoRemove/); assert.match(main, /PlayerSetlistArchive::canUndoRemove/); assert.match(main, /Setlist is full; remove a song before undoing/); diff --git a/tests/player_setlist_archive_test.cpp b/tests/player_setlist_archive_test.cpp index 9b15c4259..e41daed12 100644 --- a/tests/player_setlist_archive_test.cpp +++ b/tests/player_setlist_archive_test.cpp @@ -7,6 +7,7 @@ #include #include "../src/PlayerSetlistArchive.h" #include "../src/PlayerSetlistRepository.h" +#include "../src/PlayerSetlistEditTransaction.h" using Archive=armix::player::PlayerSetlistArchive; using SavedSet=armix::player::PlayerSavedSet; @@ -266,6 +267,90 @@ int main() { const auto largeReload=Store::load(target); assert(largeReload.document && largeReload.document->sets[0].files.size()==2000); assert(largeReload.document->sets[0].controls.size()==2000); + // N-MOD-16: durable-first metadata edit. An accepted write changes + // neither the caller's live model nor its deck until it explicitly adopts + // the returned candidate. The disk is the acceptance boundary. + using Edit=armix::player::PlayerSetlistEditTransaction; + const auto transactionFile=sandbox.getChildFile("transactional-setlists.json"); + auto originalSets=doc->sets; + const auto originalName=originalSets[0].name; + auto liveFiles=originalSets[0].files; + auto liveControls=originalSets[0].controls; + liveFiles.push_back(juce::File(tempRoot.getChildFile("nmod16-new-track.wav"))); + liveControls.push_back({}); + const auto created=Edit::apply(transactionFile,originalSets,0, + liveFiles,liveControls,true,250,Edit::Command::create); + assert(created.committed() && created.active==2); + assert(created.sets.size()==3 && created.sets[0].files.size()==3); + assert(originalSets.size()==2 && originalSets[0].files.size()==2); + const auto createdOnDisk=Store::load(transactionFile); + assert(createdOnDisk.document && createdOnDisk.document->active==2); + assert(createdOnDisk.document->sets[0].files.size()==3); + auto selected=Edit::apply(transactionFile,created.sets,created.active, + created.sets[2].files,created.sets[2].controls,true,250, + Edit::Command::select,0); + assert(selected.committed() && selected.active==0); + assert(Store::load(transactionFile).document->active==0); + const auto collisionBytes=transactionFile.loadFileAsString(); + const auto collision=Edit::apply(transactionFile,selected.sets,0, + selected.sets[0].files,selected.sets[0].controls,true,250, + Edit::Command::rename,-1,"live SHOW"); + assert(!collision.committed()); + assert(collision.error=="Setlist name already exists"); + assert(transactionFile.loadFileAsString()==collisionBytes); + auto renamed=Edit::apply(transactionFile,selected.sets,0, + selected.sets[0].files,selected.sets[0].controls,true,250, + Edit::Command::rename,-1," Main Gig "); + assert(renamed.committed() && renamed.sets[0].name=="Main Gig"); + assert(selected.sets[0].name==originalName); + assert(Store::load(transactionFile).document->sets[0].name=="Main Gig"); + const auto deleted=Edit::apply(transactionFile,renamed.sets,0, + renamed.sets[0].files,renamed.sets[0].controls,true,250, + Edit::Command::remove,0); + assert(deleted.committed() && deleted.active==0); + assert(deleted.sets.size()==2 && deleted.sets[0].name=="Live Show"); + assert(Store::load(transactionFile).document->sets.size()==2); + const auto written=transactionFile.loadFileAsString(); + const auto failed=Edit::apply(blocked,renamed.sets,0, + renamed.sets[0].files,renamed.sets[0].controls,true,250, + Edit::Command::remove,0); + assert(!failed.committed() && failed.status==Store::SaveStatus::ioError); + assert(renamed.sets.size()==3 && renamed.sets[0].name=="Main Gig"); + assert(transactionFile.loadFileAsString()==written); + assert(notDirectory.loadFileAsString()=="must not be replaced"); + const auto badCardinality=Edit::apply(transactionFile,renamed.sets,0, + renamed.sets[0].files,{},true,250,Edit::Command::rename,-1,"Good"); + assert(!badCardinality.committed()); + assert(transactionFile.loadFileAsString()==written); + const std::vector lastOne{{"One",{}, {}}}; + const auto deleteLast=Edit::apply(transactionFile,lastOne,0,{}, {}, + false,180,Edit::Command::remove,0); + assert(!deleteLast.committed()); + assert(transactionFile.loadFileAsString()==written); + // N-MOD-16 active-track replacement is a transaction too. Invalid + // media/control cardinality and occupied destinations never modify disk + // or require the caller to advance playback/queue indices. + auto revisedFiles=deleted.sets[0].files; + auto revisedControls=deleted.sets[0].controls; + revisedFiles.push_back(tempRoot.getChildFile("nmod16-import.mp3")); + revisedControls.push_back({}); + const auto committedTracks=Edit::replaceActiveTracks(transactionFile, + deleted.sets,deleted.active,revisedFiles,revisedControls,true,250); + assert(committedTracks.committed()); + assert(committedTracks.sets[0].files.size()==1); + assert(deleted.sets[0].files.empty()); + assert(Store::load(transactionFile).document->sets[0].files.size()==1); + const auto tracksBytes=transactionFile.loadFileAsString(); + const auto rejectedTracks=Edit::replaceActiveTracks(transactionFile, + committedTracks.sets,0,revisedFiles,{},true,250); + assert(!rejectedTracks.committed()); + assert(transactionFile.loadFileAsString()==tracksBytes); + const auto failedTracks=Edit::replaceActiveTracks(blocked, + committedTracks.sets,0,revisedFiles,revisedControls,true,250); + assert(!failedTracks.committed() && + failedTracks.status==Store::SaveStatus::ioError); + assert(committedTracks.sets[0].files.size()==1); + assert(transactionFile.loadFileAsString()==tracksBytes); assert(sandbox.deleteRecursively()); // Legacy empty v3 content migrates to a non-destructive default setlist.