Filter group output mods from profile link cache

was locking output files

Author: Noggog

Synthesis.Bethesda.GUI/ViewModels/Profiles/Plugins/ProfileSimpleLinkCache.cs

@@ -3,6 +3,8 @@
 using DynamicData;
 using Mutagen.Bethesda;
 using Mutagen.Bethesda.Environments.DI;
+using Mutagen.Bethesda.Plugins;
+using Mutagen.Bethesda.Plugins.Analysis;
 using Mutagen.Bethesda.Plugins.Cache;
 using Mutagen.Bethesda.Plugins.Records;
 using Noggog;
@@ -19,6 +21,11 @@ public interface IProfileSimpleLinkCacheVm
     ILinkCache? SimpleLinkCache { get; }
 }
 
+public interface IProfileGroupModKeyProvider
+{
+    IObservable<IReadOnlySet<ModKey>> GroupModKeys { get; }
+}
+
 public class ProfileSimpleLinkCacheVm : ViewModel, IProfileSimpleLinkCacheVm
 {
     private readonly ObservableAsPropertyHelper<ILinkCache?> _simpleLinkCache;
@@ -29,6 +36,7 @@ public ProfileSimpleLinkCacheVm(
         IGameReleaseContext gameReleaseContext,
         IProfileLoadOrder loadOrder,
         IProfileOverridesVm overrides,
+        IProfileGroupModKeyProvider groupModKeyProvider,
         ISchedulerProvider schedulerProvider)
     {
         _simpleLinkCache = Observable.CombineLatest(
@@ -37,27 +45,37 @@ public ProfileSimpleLinkCacheVm(
                     .QueryWhenChanged()
                     .Select(q => q.Where(x => x.Enabled).Select(x => x.ModKey).ToArray())
                     .StartWithEmpty(),
-                (dataFolder, loadOrder) => (dataFolder, loadOrder))
+                groupModKeyProvider.GroupModKeys,
+                (dataFolder, loadOrder, groupKeys) => (dataFolder, loadOrder, groupKeys))
             .Throttle(TimeSpan.FromMilliseconds(100), schedulerProvider.TaskPool)
             .Select(x =>
             {
+                // Exclude Synthesis output mods (and their split siblings like _1, _2, etc.)
+                // from the link cache import. Importing them would hold file handles via
+                // binary overlays, blocking MoveFinalResults from overwriting them on
+                // subsequent runs.
+                var filteredLoadOrder = x.loadOrder
+                    .Where(mk => !x.groupKeys.Contains(mk)
+                                 && !x.groupKeys.Any(gk => MultiModFileAnalysis.IsSplitModSibling(mk, gk)))
+                    .ToArray();
+
                 return Observable.Create<(ILinkCache? Cache, IDisposable Disposable)>(obs =>
                 {
                     try
                     {
-                        var loadOrder = Mutagen.Bethesda.Plugins.Order.LoadOrder.Import(
+                        var importedLoadOrder = Mutagen.Bethesda.Plugins.Order.LoadOrder.Import(
                             x.dataFolder,
-                            x.loadOrder,
+                            filteredLoadOrder,
                             gameReleaseContext.Release,
                             factory: (modPath) => ModInstantiator.ImportGetter(modPath, gameReleaseContext.Release));
                         obs.OnNext(
-                            (loadOrder.ToUntypedImmutableLinkCache(LinkCachePreferences.OnlyIdentifiers()),
-                                loadOrder));
-                        obs.OnCompleted();
-                        // ToDo
-                        // Figure out why returning this is disposing too early.
-                        // Gets disposed undesirably, which makes formlink pickers fail
-                        // return loadOrder;
+                            (importedLoadOrder.ToUntypedImmutableLinkCache(LinkCachePreferences.OnlyIdentifiers()),
+                                importedLoadOrder));
+                        // Don't call OnCompleted - it triggers immediate subscription disposal,
+                        // which would dispose the load order before DisposePrevious can manage it.
+                        // Instead, return it as the disposable so Switch() disposes it
+                        // when a new inner observable arrives or when the chain tears down.
+                        return importedLoadOrder;
                     }
                     catch (Exception ex)
                     {

Synthesis.Bethesda.GUI/ViewModels/Profiles/ProfileVm.cs

@@ -37,7 +37,7 @@
 
 namespace Synthesis.Bethesda.GUI.ViewModels.Profiles;
 
-public class ProfileVm : ViewModel
+public class ProfileVm : ViewModel, IProfileGroupModKeyProvider
 {
     private readonly StartRun _startRun;
     private readonly ILogger _logger;
@@ -100,6 +100,8 @@ public class ProfileVm : ViewModel
 
     public IObservable<ILinkCache?> SimpleLinkCache { get; }
 
+    public IObservable<IReadOnlySet<ModKey>> GroupModKeys { get; }
+
     public ILockToCurrentVersioning LockSetting { get; }
     public IProfileExporter Exporter { get; }
 
@@ -208,6 +210,22 @@ public ProfileVm(
             .QueryWhenChanged(q => q.ToHashSet())
             .Replay(1).RefCount();
 
+        // All group mod keys (enabled and disabled) for filtering from link cache imports.
+        // Includes disabled groups since their output files may still exist in the data directory.
+        GroupModKeys = Groups.Connect()
+            .Transform(x => x.ModKey)
+            .QueryWhenChanged(q =>
+            {
+                var set = new HashSet<ModKey>();
+                foreach (var r in q)
+                {
+                    if (r.Succeeded) set.Add(r.Value);
+                }
+                return (IReadOnlySet<ModKey>)set;
+            })
+            .StartWith((IReadOnlySet<ModKey>)new HashSet<ModKey>())
+            .Replay(1).RefCount();
+
         _globalError = Observable.CombineLatest(
                 overrides.WhenAnyValue(x => x.DataFolderResult),
                 loadOrder.WhenAnyValue(x => x.State),