Merge remote-tracking branch 'origin/master'

add support for some basic game parameters to be set via custom config

.github/workflows/release.yaml

@@ -2,56 +2,60 @@ name: Release
 
 on:
   push:
-    tags:
+    branches: [master]
-      - '*'
 
 jobs:
   build:
     name: Build
     runs-on: ubuntu-latest
     env:
-      TORCH_VERSION: ${{ github.ref_name }}
       BUILD_CONFIGURATION: Release
       DOTNET_NOLOGO: true
       DOTNET_CLI_TELEMETRY_OPTOUT: true
     steps:
       - uses: actions/checkout@master
         name: Checkout
+        with:
+          ref: ${{ github.head_ref }}
+          fetch-depth: 0
+          
       - uses: actions/setup-dotnet@v3
         name: Setup dotnet
         with:
           dotnet-version: '7.0.x'
+          
       - name: Add Gh Packages Nuget Source
         run: dotnet nuget add source "https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json" --username ${{ github.actor }} --password ${{ secrets.GITHUB_TOKEN }} --store-password-in-clear-text --name github
       - name: Restore dependencies
         run: dotnet restore Torch.Server/Torch.Server.csproj --locked-mode
+        
+      - name: Git Version
+        id: version
+        uses: codacy/git-version@2.7.1
+        
       - name: Build
-        run: dotnet build Torch.Server/Torch.Server.csproj --no-restore -c ${{ env.BUILD_CONFIGURATION }} /p:AssemblyVersion=${{ env.TORCH_VERSION }} /p:Version=${{ env.TORCH_VERSION }}
+        run: dotnet build Torch.Server/Torch.Server.csproj --no-restore -c ${{ env.BUILD_CONFIGURATION }} -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}"
       - name: Publish
         run: dotnet publish Torch.Server/Torch.Server.csproj --no-build -r win-x64 --sc -c ${{ env.BUILD_CONFIGURATION }} -o ./publish
+      
       - uses: vimtor/action-zip@v1
         name: Zip Release
         with:
           files: publish/
           dest: release.zip
-      - name: Build Changelog
+      
-        id: build_changelog
-        uses: mikepenz/release-changelog-builder-action@v3
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          commitMode: true
       - name: Create release
         id: create_release
         uses: actions/create-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          tag_name: ${{ env.TORCH_VERSION }}
+          tag_name: ${{ steps.version.outputs.version }}
-          release_name: Release v${{ env.TORCH_VERSION }}
+          release_name: Release v${{ steps.version.outputs.version }}
           body: ${{ steps.github_release.outputs.changelog }}
           draft: true
           prerelease: false
+      
       - name: Upload release asset
         uses: actions/upload-release-asset@v1
         env:
@@ -61,9 +65,16 @@ jobs:
           asset_path: release.zip
           asset_name: torch-server.zip
           asset_content_type: application/zip
-      - name: Publish release
+      
-        uses: StuYarrow/publish-release@v1
+      - uses: eregon/publish-release@v1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          id: ${{ steps.create_release.outputs.id }}
+          release_id: ${{ steps.create_release.outputs.id }}
+          
+      - run: dotnet pack -c Release ./Torch.API/Torch.API.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}" --no-build
+      - run: dotnet pack -c Release ./Torch/Torch.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}" --no-build
+      - run: dotnet pack -c Release ./Torch.Server/Torch.Server.csproj -o pack --include-symbols -p:SymbolPackageFormat=snupkg -p:Version="${{ steps.version.outputs.version }}" -p:AssemblyVersion="${{ steps.version.outputs.version }}" --no-build
+      - run: mkdir blank && sed -i 's/torchVersion/${{ steps.version.outputs.version }}/g' Torch.Server.ReferenceAssemblies.net7.nuspec && nuget pack Torch.Server.ReferenceAssemblies.net7.nuspec -BasePath ./blank -OutputDirectory pack -NonInteractive -NoPackageAnalysis
+  
+      - run: dotnet nuget push ./pack/*.nupkg -s github 

.gitignore

@@ -159,10 +159,6 @@ publish/
 
 # NuGet Packages
 *.nupkg
-# The packages folder can be ignored because of Package Restore
-**/packages/*
-# except build/, which is used as an MSBuild target.
-!**/packages/build/
 # Uncomment if necessary however generally it will be regenerated when needed
 #!**/packages/repositories.config
 # NuGet v3's project.json files produces more ignoreable files

Torch.API/ITorchBase.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
 using Torch.API.Managers;
 using Torch.API.Session;
 using VRage.Game.ModAPI;
@@ -26,6 +27,11 @@ namespace Torch.API
         /// </summary>
         ITorchConfig Config { get; }
         
+        /// <summary>
+        /// Extended Configuration for the current instance.
+        /// </summary>
+        IConfiguration Configuration { get; }
+
         /// <inheritdoc cref="IPluginManager"/>
         [Obsolete]
         IPluginManager Plugins { get; }

Torch.API/ITorchConfig.cs

@@ -33,6 +33,7 @@ namespace Torch
         bool EntityManagerEnabled { get; set; }
         string LoginToken { get; set; }
         UpdateSource UpdateSource { get; set; }
+        List<string> Packages { get; set; }
 
         void Save(string path = null);
     }

Torch.API/Managers/IPackageManager.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Reflection;
+using System.Runtime.Loader;
+using Torch.API.WebAPI.Plugins;
+
+namespace Torch.API.Managers;
+
+public interface IPackageManager : IManager
+{
+    IReadOnlySet<Package> Packages { get; }
+
+    bool TryGetPackageAssemblies(Package package, [MaybeNullWhen(false)] out Assembly[] assemblies);
+}

Torch.API/Managers/IPluginManager.cs

@@ -14,6 +14,9 @@ namespace Torch.API.Managers
         /// <summary>
         /// Fired when plugins are loaded.
         /// </summary>
+        /// <remarks>
+        /// Fired when plugins are loaded and immediately if subscribed after the plugins are loaded.
+        /// </remarks>
         event Action<IReadOnlyCollection<ITorchPlugin>> PluginsLoaded;
 
         /// <summary>

Torch.API/Torch.API.csproj

@@ -17,11 +17,15 @@
   
   <ItemGroup>
     <PackageReference Include="JorgeSerrano.Json.JsonSnakeCaseNamingPolicy" Version="0.9.0" />
-    <PackageReference Include="NLog" Version="5.1.0" />
+    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="7.0.4" />
+    <PackageReference Include="NLog" Version="5.2.2" />
+    <PackageReference Include="NuGet.Commands" Version="6.6.1" />
+    <PackageReference Include="NuGet.DependencyResolver.Core" Version="6.6.1" />
     <PackageReference Include="SemanticVersioning" Version="2.0.2" />
-    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.201.13">
+    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.203.22">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>compile</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="System.Linq.Async" Version="6.0.1" />
   </ItemGroup>
 </Project>

Torch.API/WebAPI/Plugins/IPackageItem.cs

@@ -0,0 +1,11 @@
+#nullable enable
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public interface IPackageItem
+{
+    Task<Stream> OpenFileAsync();
+    public string FileName { get; }
+}

Torch.API/WebAPI/Plugins/IPackageReader.cs

@@ -0,0 +1,12 @@
+#nullable enable
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public interface IPackageReader
+{
+    Task<(IEnumerable<IPackageItem> Root, IReadOnlyDictionary<PackageDependency, IEnumerable<IPackageItem>> Dependencies)> GetItemsAsync();
+}

Torch.API/WebAPI/Plugins/IPackageResolver.cs

@@ -0,0 +1,11 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public interface IPackageResolver
+{
+    Task<IEnumerable<Package>> ResolvePackagesAsync(IReadOnlyDictionary<string, string> packages);
+    Task<IPackageReader> GetPackageAsync(Package package);
+}

Torch.API/WebAPI/Plugins/NLogLogger.cs

@@ -0,0 +1,87 @@
+#nullable enable
+using System;
+using System.Threading.Tasks;
+using NuGet.Common;
+
+namespace Torch.API.WebAPI.Plugins;
+
+internal class NLogLogger : ILogger
+{
+    private readonly NLog.ILogger _logger;
+
+    public NLogLogger(NLog.ILogger logger)
+    {
+        _logger = logger;
+    }
+
+    public void LogDebug(string data)
+    {
+        _logger.Debug(data);
+    }
+
+    public void LogVerbose(string data)
+    {
+        _logger.Trace(data);
+    }
+
+    public void LogInformation(string data)
+    {
+        _logger.Info(data);
+    }
+
+    public void LogMinimal(string data)
+    {
+        _logger.Debug(data);
+    }
+
+    public void LogWarning(string data)
+    {
+        _logger.Warn(data);
+    }
+
+    public void LogError(string data)
+    {
+        _logger.Error(data);
+    }
+
+    public void LogInformationSummary(string data)
+    {
+        _logger.Info(data);
+    }
+
+    public void Log(LogLevel level, string data)
+    {
+        _logger.Log(ToNLogLevel(level), data);
+    }
+
+    private static NLog.LogLevel ToNLogLevel(LogLevel level)
+    {
+        return level switch
+        {
+            LogLevel.Debug => NLog.LogLevel.Debug,
+            LogLevel.Verbose => NLog.LogLevel.Trace,
+            LogLevel.Information => NLog.LogLevel.Info,
+            LogLevel.Minimal => NLog.LogLevel.Debug,
+            LogLevel.Warning => NLog.LogLevel.Warn,
+            LogLevel.Error => NLog.LogLevel.Error,
+            _ => throw new ArgumentOutOfRangeException(nameof(level), level, null)
+        };
+    }
+
+    public Task LogAsync(LogLevel level, string data)
+    {
+        Log(level, data);
+        return Task.CompletedTask;
+    }
+
+    public void Log(ILogMessage message)
+    {
+        _logger.Log(ToNLogLevel(message.Level), message.FormatWithCode);
+    }
+
+    public Task LogAsync(ILogMessage message)
+    {
+        Log(message);
+        return Task.CompletedTask;
+    }
+}

Torch.API/WebAPI/Plugins/Package.cs

@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using NuGet.DependencyResolver;
+using SemanticVersioning;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public record Package(string Name, Version Version, IReadOnlySet<PackageDependency> Dependencies)
+{
+    internal GraphItem<RemoteResolveResult> Graph { get; init; }
+}

Torch.API/WebAPI/Plugins/PackageDependency.cs

@@ -0,0 +1,9 @@
+using NuGet.DependencyResolver;
+using SemanticVersioning;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public record PackageDependency(string Name, Version Version, PackageDependencyKind Kind)
+{
+    internal RemoteMatch Match { get; init; }
+}

Torch.API/WebAPI/Plugins/PackageDependencyKind.cs

@@ -0,0 +1,8 @@
+namespace Torch.API.WebAPI.Plugins;
+
+public enum PackageDependencyKind
+{
+    None,
+    Transitive,
+    Direct
+}

Torch.API/WebAPI/Plugins/PackageReader.cs

@@ -0,0 +1,91 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using NuGet.Common;
+using NuGet.DependencyResolver;
+using NuGet.Frameworks;
+using NuGet.Packaging;
+using NuGet.Protocol.Core.Types;
+using NuGet.Versioning;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public class PackageReader : IPackageReader
+{
+    private readonly Package _package;
+    private readonly SourceCacheContext _cacheContext;
+    private readonly ILogger _logger;
+    private readonly NuGetFramework _framework;
+    private readonly IFrameworkCompatibilityProvider _compatibilityProvider;
+    private readonly DirectoryInfo _packagesDirectory;
+
+    public PackageReader(Package package, SourceCacheContext cacheContext, ILogger logger, NuGetFramework framework,
+                         IFrameworkCompatibilityProvider compatibilityProvider, DirectoryInfo packagesDirectory)
+    {
+        _package = package;
+        _cacheContext = cacheContext;
+        _logger = logger;
+        _framework = framework;
+        _compatibilityProvider = compatibilityProvider;
+        _packagesDirectory = packagesDirectory;
+    }
+
+    public async Task<(IEnumerable<IPackageItem> Root, IReadOnlyDictionary<PackageDependency, IEnumerable<IPackageItem>>
+            Dependencies)>
+        GetItemsAsync()
+    {
+        async Task<IEnumerable<IPackageItem>> GetPackageItemsAsync(string id, NuGetVersion version,
+                                                                   IRemoteDependencyProvider provider)
+        {
+            var downloader =
+                await provider.GetPackageDownloaderAsync(new(id, version), _cacheContext, _logger,
+                                                         CancellationToken.None);
+
+            await downloader.CopyNupkgFileToAsync(Path.Combine(_packagesDirectory.FullName, $"{id}.{version}.nupkg"),
+                                                  CancellationToken.None);
+
+            var frameworks = await downloader.ContentReader.GetReferenceItemsAsync(CancellationToken.None);
+            var items = frameworks.Where(b => _compatibilityProvider.IsCompatible(_framework, b.TargetFramework))
+                                  .MaxBy(b => b.TargetFramework.Version)?.Items;
+
+            return items?.Select(b => new PackageItem(b, downloader)) ?? ImmutableArray<PackageItem>.Empty;
+        }
+
+        var rootIdentity = _package.Graph.Key;
+        return (await GetPackageItemsAsync(rootIdentity.Name, rootIdentity.Version, _package.Graph.Data.Match.Provider),
+            await _package.Dependencies.ToAsyncEnumerable().SelectManyAwait(async b =>
+                                                                                (await GetPackageItemsAsync(
+                                                                                    b.Match.Library.Name,
+                                                                                    b.Match.Library.Version,
+                                                                                    b.Match.Provider))
+                                                                                .ToAsyncEnumerable()
+                                                                                .Select(c => (b, c)))
+                          .GroupBy(b => b.b, b => b.c)
+                          .ToDictionaryAwaitAsync<IAsyncGrouping<PackageDependency, IPackageItem>, PackageDependency,
+                              IEnumerable<IPackageItem>>(b => ValueTask.FromResult(b.Key),
+                                                         async b => await b.ToArrayAsync()));
+    }
+}
+
+file class PackageItem : IPackageItem
+{
+    private readonly string _path;
+    private readonly IPackageDownloader _downloader;
+
+    public string FileName => Path.GetFileName(_path);
+
+    public PackageItem(string path, IPackageDownloader downloader)
+    {
+        _path = path;
+        _downloader = downloader;
+    }
+
+    public Task<Stream> OpenFileAsync()
+    {
+        return _downloader.CoreReader.GetStreamAsync(_path, CancellationToken.None);
+    }
+}

Torch.API/WebAPI/Plugins/PackageResolver.cs

@@ -0,0 +1,104 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using NLog;
+using NuGet.Commands;
+using NuGet.Configuration;
+using NuGet.DependencyResolver;
+using NuGet.Frameworks;
+using NuGet.LibraryModel;
+using NuGet.Protocol;
+using NuGet.Protocol.Core.Types;
+using NuGet.Versioning;
+using Version = SemanticVersioning.Version;
+
+namespace Torch.API.WebAPI.Plugins;
+
+public class PackageResolver : IPackageResolver
+{
+    private static readonly ILogger Log = LogManager.GetCurrentClassLogger();
+
+    private readonly NuGetFramework _framework = NuGetFramework.Parse("net7.0-windows7.0");
+    private readonly NLogLogger _logger = new(Log);
+    private readonly SourceCacheContext _sourceCacheContext = new();
+    private readonly RemoteWalkContext _remoteWalkContext;
+    private readonly DirectoryInfo _packagesDirectory;
+    private readonly IFrameworkCompatibilityProvider _compatibilityProvider = DefaultCompatibilityProvider.Instance;
+
+    public PackageResolver(IEnumerable<PackageSource> sources, DirectoryInfo packagesDirectory)
+    {
+        _packagesDirectory = packagesDirectory;
+        IReadOnlySet<PackageSource> packageSources = sources.Where(b => b.Type is PackageSourceType.NuGet).ToImmutableHashSet();
+
+        var mapping = new PackageSourceMapping(packageSources.ToDictionary(b => b.Name, b => b.Patterns));
+        _remoteWalkContext = new RemoteWalkContext(_sourceCacheContext, mapping, _logger);
+
+        foreach (var (name, url, _, _) in packageSources)
+        {
+            var packageSource = new NuGet.Configuration.PackageSource(url, name);
+            var sourceRepository = new SourceRepository(packageSource, new INuGetResourceProvider[]
+            {
+                new DownloadResourceV3Provider(),
+                new DependencyInfoResourceV3Provider(),
+                new ServiceIndexResourceV3Provider(),
+                new RemoteV3FindPackageByIdResourceProvider(),
+                new V3FeedListResourceProvider(),
+                new HttpSourceResourceProvider(),
+                new RegistrationResourceV3Provider(),
+                new HttpHandlerResourceV3Provider()
+            }.Select(b => new Lazy<INuGetResourceProvider>(b)), FeedType.HttpV3);
+
+            _remoteWalkContext.RemoteLibraryProviders.Add(
+                new SourceRepositoryDependencyProvider(sourceRepository, _logger, _sourceCacheContext, true, false));
+        }
+    }
+
+    public async Task<IEnumerable<Package>> ResolvePackagesAsync(
+        IReadOnlyDictionary<string, string> packages)
+    {
+        Log.Info("Restoring {0} packages", packages.Count);
+
+        var graphs = await Task.WhenAll(packages.Select(b =>
+        {
+            var (key, versionRange) = b;
+            var libraryRange = new LibraryRange(key, VersionRange.Parse(versionRange), LibraryDependencyTarget.All);
+            return ResolverUtility.FindLibraryEntryAsync(libraryRange, _framework, "win-x64",
+                                                         _remoteWalkContext, CancellationToken.None);
+        }));
+
+        return await graphs.ToAsyncEnumerable().SelectAwait(async graph =>
+        {
+            return new Package(graph.Key.Name, Version.Parse(graph.Key.Version.ToFullString()),
+                               await graph.Data.Dependencies
+                                          .ToAsyncEnumerable()
+                                          .SelectAwait(async b =>
+                                          {
+                                              var match = await ResolverUtility.FindLibraryByVersionAsync(
+                                                  b.LibraryRange, _framework, _remoteWalkContext.RemoteLibraryProviders,
+                                                  _sourceCacheContext, _logger, CancellationToken.None);
+
+                                              return new PackageDependency(
+                                                  b.Name, Version.Parse(match.Library.Version.ToFullString()),
+                                                  (PackageDependencyKind)b.ReferenceType)
+                                              {
+                                                  Match = match
+                                              };
+                                          })
+                                          .ToHashSetAsync())
+            {
+                Graph = graph
+            };
+        }).ToArrayAsync();
+    }
+
+    public Task<IPackageReader> GetPackageAsync(Package package)
+    {
+        var reader = new PackageReader(package, _sourceCacheContext, _logger, _framework, _compatibilityProvider, _packagesDirectory);
+        return Task.FromResult<IPackageReader>(reader);
+    }
+}

Torch.API/WebAPI/Plugins/PackageSource.cs

@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+
+namespace Torch.API.WebAPI.Plugins;
+
+#nullable enable
+public record PackageSource
+#nullable restore
+    (string Name, string Url, IReadOnlyList<string> Patterns, PackageSourceType Type);

Torch.API/WebAPI/Plugins/PackageSourceType.cs

@@ -0,0 +1,8 @@
+#nullable enable
+namespace Torch.API.WebAPI.Plugins;
+
+public enum PackageSourceType
+{
+    NuGet,
+    LegacyTorch
+}

Torch.API/packages.lock.json

@@ -8,11 +8,43 @@
         "resolved": "0.9.0",
         "contentHash": "xCqODS+wzpUXNtg4bMMvXG5PLbP0iTwRzRn2R+zWHKm83E6tbV2bCagawXp1EnZeNpd5OXpMxehulZWns8efzQ=="
       },
+      "Microsoft.Extensions.Configuration.Binder": {
+        "type": "Direct",
+        "requested": "[7.0.4, )",
+        "resolved": "7.0.4",
+        "contentHash": "8+XPvJnHZsYgHOQlcMuQe7QNF5KdVKHH1F/wW3nd8/u81Gk/XFAYMDP0Lpz18h7/AM95M662vvqMorcYxCBB4w==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "7.0.0"
+        }
+      },
       "NLog": {
         "type": "Direct",
-        "requested": "[5.1.0, )",
+        "requested": "[5.2.2, )",
-        "resolved": "5.1.0",
+        "resolved": "5.2.2",
-        "contentHash": "oW7ekrkRG9okpDMUcEglunWj8Qf2RY8qkgl+/chJoavzg3dbT13y32t19R54FKkmq80fKzw4ZekZkCrRGanKgQ=="
+        "contentHash": "r6Q9740g29gTwmTWlsgdIFm0mhNsfNZmbvWKX/Fxmi8X89ZrpUowHM2T2X1lP7RVpND+ef+XnfKL5g6Q1iNGXA=="
+      },
+      "NuGet.Commands": {
+        "type": "Direct",
+        "requested": "[6.6.1, )",
+        "resolved": "6.6.1",
+        "contentHash": "D1b7gTk1wp7sxscLhS8O/yoErsRVbR4zJvLVD4jo1sgxh42ZOWKpMkhznPUxpvmCxBhw9hAy8/yWrRH91SfdEQ==",
+        "dependencies": {
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileSystemGlobbing": "6.0.0",
+          "NuGet.Credentials": "6.6.1",
+          "NuGet.ProjectModel": "6.6.1"
+        }
+      },
+      "NuGet.DependencyResolver.Core": {
+        "type": "Direct",
+        "requested": "[6.6.1, )",
+        "resolved": "6.6.1",
+        "contentHash": "K+EXXLU37PBnwLGx6WnVGxlfWYkdedvUUOeDMERXelNgjg20irtKf3hk+wGB7NmxAdNY9/gGcOgSDOV+M0w3Jg==",
+        "dependencies": {
+          "NuGet.Configuration": "6.6.1",
+          "NuGet.LibraryModel": "6.6.1",
+          "NuGet.Protocol": "6.6.1"
+        }
       },
       "SemanticVersioning": {
         "type": "Direct",
@@ -22,17 +54,161 @@
       },
       "SpaceEngineersDedicated.ReferenceAssemblies": {
         "type": "Direct",
-        "requested": "[1.201.13, )",
+        "requested": "[1.203.22, )",
-        "resolved": "1.201.13",
+        "resolved": "1.203.22",
-        "contentHash": "FRXuNLENsz5jGQvL0QkogAGsxEJyUQlXhvWHBWfZiHCnCrAWMD60nEis6yt0xCQpazszfMtHonbxz72XMxnFoQ==",
+        "contentHash": "ruf6DT1sAh2DnpsJUsGG4ZSdPKrVr5ReKfHSDcYggeacge/nsdqpcij53HSNwnMxve6cfnTRG9SXE2iGSGEtEQ==",
         "dependencies": {
           "protobuf-net": "1.0.0"
         }
       },
+      "System.Linq.Async": {
+        "type": "Direct",
+        "requested": "[6.0.1, )",
+        "resolved": "6.0.1",
+        "contentHash": "0YhHcaroWpQ9UCot3Pizah7ryAzQhNvobLMSxeDIGmnXfkQn8u5owvpOH0K6EVB+z9L7u6Cc4W17Br/+jyttEQ==",
+        "dependencies": {
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0"
+        }
+      },
+      "Microsoft.Bcl.AsyncInterfaces": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "UcSjPsst+DfAdJGVDsu346FX0ci0ah+lw3WRtn18NUwEqRt70HaOQ7lI72vy3+1LxtqI3T5GWwV39rQSrCzAeg=="
+      },
+      "Microsoft.Extensions.Configuration.Abstractions": {
+        "type": "Transitive",
+        "resolved": "7.0.0",
+        "contentHash": "f34u2eaqIjNO9YLHBz8rozVZ+TcFiFs0F3r7nUJd7FRkVSxk8u4OpoK226mi49MwexHOR2ibP9MFvRUaLilcQQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "7.0.0"
+        }
+      },
+      "Microsoft.Extensions.FileProviders.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "0pd4/fho0gC12rQswaGQxbU34jOS1TPS8lZPpkFCH68ppQjHNHYle9iRuHeev1LhrJ94YPvzcRd8UmIuFk23Qw==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "6.0.0"
+        }
+      },
+      "Microsoft.Extensions.FileSystemGlobbing": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "ip8jnL1aPiaPeKINCqaTEbvBFDmVx9dXQEBZ2HOBRXPD1eabGNqP/bKlsIcp7U2lGxiXd5xIhoFcmY8nM4Hdiw=="
+      },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "7.0.0",
+        "contentHash": "um1KU5kxcRp3CNuI8o/GrZtD4AIOXDk+RLsytjZ9QPok3ttLUelLKpilVPuaFT3TFjOhSibUAso0odbOaCDj3Q=="
+      },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.1",
+        "contentHash": "ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A=="
+      },
+      "NuGet.Common": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "hW5NtShErO3qbdkyv7doCRsFNK9Rlcc7mVjYM+hg1sOAWheTh/oo95DzNbsZthiqyHZfaioopfWtzmoxNw9h4g==",
+        "dependencies": {
+          "NuGet.Frameworks": "6.6.1"
+        }
+      },
+      "NuGet.Configuration": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "9WbK8wgwPfRpSwuG+ZhMshE48qUYvPIw7VNLCncrq/in4vE6SGsuawPSxPJkkLBtcKTGbPMez5JDvUf6vEBgKg==",
+        "dependencies": {
+          "NuGet.Common": "6.6.1",
+          "System.Security.Cryptography.ProtectedData": "4.4.0"
+        }
+      },
+      "NuGet.Credentials": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "TuOlXcE1ajwdtfnQaUjDv2xO2u/WDS56/b5jHfEBZetKfcpT0W3iNOqInVPO0qxRxXK5/HXUKVr2Pya1LsVVnA==",
+        "dependencies": {
+          "NuGet.Protocol": "6.6.1"
+        }
+      },
+      "NuGet.Frameworks": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "iRtDhL0zPqVw037fHEK9bQljTKPuOHhfIkz86/IH2P8eetr910HTTe5G8lJTuzZHh592Ze/sYhh173HIFjPSfg=="
+      },
+      "NuGet.LibraryModel": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "B0KH19sNNUq56YfEozIsIpk8EOyolG0LRT+hqG1/mhuXlQFiP9BgT6pZgwLQVLUl9YBDx3+KWQQbl6pz8Yh/Sw==",
+        "dependencies": {
+          "NuGet.Common": "6.6.1",
+          "NuGet.Versioning": "6.6.1"
+        }
+      },
+      "NuGet.Packaging": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "GwhFi2Ep4YzAGQFYz1OsMVNfiJ1M46nyCgHQ7xjJSMvxDYFgodR1RqVugWFMbIUUq6I8iYASwp5lpHXvITeuIQ==",
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "NuGet.Configuration": "6.6.1",
+          "NuGet.Versioning": "6.6.1",
+          "System.Security.Cryptography.Cng": "5.0.0",
+          "System.Security.Cryptography.Pkcs": "5.0.0"
+        }
+      },
+      "NuGet.ProjectModel": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "CEyRXXvgIoEQBWn3WZupjkIVC6rPcGUAO5p4Gz+fnF8kcefWQOXHfnOE+UKZ0WwAJG5iMWRvXBKAGOuFiFhNpQ==",
+        "dependencies": {
+          "NuGet.DependencyResolver.Core": "6.6.1"
+        }
+      },
+      "NuGet.Protocol": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "HhKLsK6Q0NNp6qb0T26GLR5gCTRZu+gzqDVK4xqXHZmsolaDVIdIYpn44b2etaVYLzNJCvgRkw+I422u2bIvMw==",
+        "dependencies": {
+          "NuGet.Packaging": "6.6.1"
+        }
+      },
+      "NuGet.Versioning": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "Wm/AOFICTIrCgbVxv9dNWusraTzcggbo5W4ao7hD8NNVq911an9TGwW+uNuYc8I5PkpTeMuSXneV2u6hbi1P4w=="
+      },
       "protobuf-net": {
         "type": "Transitive",
         "resolved": "1.0.0",
         "contentHash": "kTGOK0E87473sOImOjgZOnz3kTC2aMLffoRWQLYNuBLJnwNNmjanF9IkevZ9Q7yYLeABQfcF3BpeepuMntMVNw=="
+      },
+      "System.Formats.Asn1": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "MTvUIktmemNB+El0Fgw9egyqT9AYSIk6DTJeoDSpc3GIHxHCMo8COqkWT1mptX5tZ1SlQ6HJZ0OsSvMth1c12w=="
+      },
+      "System.Security.Cryptography.Cng": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "jIMXsKn94T9JY7PvPq/tMfqa6GAaHpElRDpmG+SuL+D3+sTw2M8VhnibKnN8Tq+4JqbPJ/f+BwtLeDMEnzAvRg==",
+        "dependencies": {
+          "System.Formats.Asn1": "5.0.0"
+        }
+      },
+      "System.Security.Cryptography.Pkcs": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "9TPLGjBCGKmNvG8pjwPeuYy0SMVmGZRwlTZvyPHDbYv/DRkoeumJdfumaaDNQzVGMEmbWtg07zUpSW9q70IlDQ==",
+        "dependencies": {
+          "System.Formats.Asn1": "5.0.0",
+          "System.Security.Cryptography.Cng": "5.0.0"
+        }
+      },
+      "System.Security.Cryptography.ProtectedData": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "cJV7ScGW7EhatRsjehfvvYVBvtiSMKgN8bOVI0bQhnF5bU7vnHVIsH49Kva7i7GWaWYvmEzkYVk1TC+gZYBEog=="
       }
     }
   }

Torch.Mod/Messages/IncomingMessage.cs

@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace Torch.Mod.Messages
-{
-    /// <summary>
-    /// shim to store incoming message data
-    /// </summary>
-    internal class IncomingMessage : MessageBase
-    {
-        public IncomingMessage()
-        {
-        }
-
-        public override void ProcessClient()
-        {
-            throw new Exception();
-        }
-
-        public override void ProcessServer()
-        {
-            throw new Exception();
-        }
-    }
-}

Torch.Mod/Messages/JoinServerMessage.cs

@@ -32,11 +32,6 @@ namespace Torch.Mod.Messages
 
         public override void ProcessClient()
         {
-            if (TorchModCore.Debug)
-            {
-                MyAPIGateway.Utilities.ShowMessage("Torch", $"Joining server {Address} with delay {Delay}");
-            }
-
             if (Delay <= 0)
             {
                 MyAPIGateway.Multiplayer.JoinServer(Address);

Torch.Mod/Messages/MessageBase.cs

@@ -1,9 +1,4 @@
-using System;
+using ProtoBuf;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using ProtoBuf;
 
 namespace Torch.Mod.Messages
 {
@@ -17,36 +12,9 @@ namespace Torch.Mod.Messages
     [ProtoContract]
     public abstract class MessageBase
     {
-        [ProtoMember(101)]
         public ulong SenderId;
 
         public abstract void ProcessClient();
         public abstract void ProcessServer();
-
-        //members below not serialized, they're just metadata about the intended target(s) of this message
-        internal MessageTarget TargetType;
-        internal ulong Target;
-        internal ulong[] Ignore;
-        internal byte[] CompressedData;
-    }
-    
-    public enum MessageTarget
-    {
-        /// <summary>
-        /// Send to Target
-        /// </summary>
-        Single,
-        /// <summary>
-        /// Send to Server
-        /// </summary>
-        Server,
-        /// <summary>
-        /// Send to all Clients (only valid from server)
-        /// </summary>
-        AllClients,
-        /// <summary>
-        /// Send to all except those steam ID listed in Ignore
-        /// </summary>
-        AllExcept,
     }
 }

Torch.Mod/ModCommunication.cs

@@ -1,161 +1,50 @@
 using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 using Sandbox.ModAPI;
 using Torch.Mod.Messages;
-using VRage;
+using VRage.Game.Components;
-using VRage.Collections;
 using VRage.Game.ModAPI;
-using VRage.Network;
+#if TORCH
-using VRage.Utils;
+using Torch.Utils;
-using Task = ParallelTasks.Task;
+using VRage.Library.Collections;
+using System.Reflection;
+#endif
 
 namespace Torch.Mod
 {
-    public static class ModCommunication
+    [MySessionComponentDescriptor(MyUpdateOrder.AfterSimulation)]
+    public class ModCommunication : MySessionComponentBase
     {
-        public const ushort NET_ID = 4352;
+        public const ulong MOD_ID = 2915950488;
-        private static bool _closing = false;
+        private const ushort CHANNEL = 7654;
-        private static BlockingCollection<MessageBase> _processing;
-        private static MyConcurrentPool<IncomingMessage> _messagePool;
-        private static List<IMyPlayer> _playerCache;
 
-        public static void Register()
+        public override void BeforeStart()
         {
-            MyLog.Default.WriteLineAndConsole("TORCH MOD: Registering mod communication.");
+            base.BeforeStart();
-            _processing = new BlockingCollection<MessageBase>(new ConcurrentQueue<MessageBase>());
+            MyAPIGateway.Multiplayer.RegisterSecureMessageHandler(CHANNEL, MessageHandler);
-            _playerCache = new List<IMyPlayer>();
-            _messagePool = new MyConcurrentPool<IncomingMessage>(8);
-
-            MyAPIGateway.Multiplayer.RegisterMessageHandler(NET_ID, MessageHandler);
-            //background thread to handle de/compression and processing
-            _closing = false;
-            MyAPIGateway.Parallel.StartBackground(DoProcessing);
-            MyLog.Default.WriteLineAndConsole("TORCH MOD: Mod communication registered successfully.");
         }
 
-        public static void Unregister()
+        private void MessageHandler(ushort channel, byte[] data, ulong sender, bool fromServer)
         {
-            MyLog.Default.WriteLineAndConsole("TORCH MOD: Unregistering mod communication.");
+            if (!fromServer)
-            MyAPIGateway.Multiplayer?.UnregisterMessageHandler(NET_ID, MessageHandler);
+                return;
-            _processing?.CompleteAdding();
+
-            _closing = true;
+            var message = MyAPIGateway.Utilities.SerializeFromBinary<MessageBase>(data);
-            //_task.Wait();
+            message.SenderId = sender;
+            
+            if (MyAPIGateway.Multiplayer.IsServer) message.ProcessServer();
+            else message.ProcessClient();
         }
 
-        private static void MessageHandler(byte[] bytes)
-        {
-            var m = _messagePool.Get();
-            m.CompressedData = bytes;
 #if TORCH
-            m.SenderId = MyEventContext.Current.Sender.Value;
+        [ReflectedMethodInfo(typeof(MyAPIUtilities), "VRage.Game.ModAPI.IMyUtilities.SerializeToBinary")]
-#endif
+        private static MethodInfo _serializeMethod = null!;
 
-            _processing.Add(m);
+        private static readonly CacheList<IMyPlayer> Players = new();
-        }
 
-        public static void DoProcessing()
+        private static byte[] Serialize(MessageBase message)
         {
-            while (!_closing)
+            return (byte[])_serializeMethod.MakeGenericMethod(message.GetType())
-            {
+                                          .Invoke(MyAPIGateway.Utilities, new object[] { message });
-                try
-                {
-                    MessageBase m;
-                    try
-                    {
-                        m = _processing.Take();
-                    }
-                    catch
-                    {
-                        continue;
-                    }
-
-                    MyLog.Default.WriteLineAndConsole($"Processing message: {m.GetType().Name}");
-
-                    if (m is IncomingMessage) //process incoming messages
-                    {
-                        MessageBase i;
-                        try
-                        {
-                            var o = MyCompression.Decompress(m.CompressedData);
-                            m.CompressedData = null;
-                            _messagePool.Return((IncomingMessage)m);
-                            i = MyAPIGateway.Utilities.SerializeFromBinary<MessageBase>(o);
-                        }
-                        catch (Exception ex)
-                        {
-                            MyLog.Default.WriteLineAndConsole($"TORCH MOD: Failed to deserialize message! {ex}");
-                            continue;
-                        }
-
-                        if (TorchModCore.Debug)
-                            MyAPIGateway.Utilities.ShowMessage("Torch", $"Received message of type {i.GetType().Name}");
-
-                        if (MyAPIGateway.Multiplayer.IsServer)
-                            i.ProcessServer();
-                        else
-                            i.ProcessClient();
-                    }
-                    else //process outgoing messages
-                    {
-                        if (TorchModCore.Debug)
-                            MyAPIGateway.Utilities.ShowMessage("Torch", $"Sending message of type {m.GetType().Name}");
-
-                        var b = MyAPIGateway.Utilities.SerializeToBinary(m);
-                        m.CompressedData = MyCompression.Compress(b);
-
-                        switch (m.TargetType)
-                        {
-                            case MessageTarget.Single:
-                                MyAPIGateway.Multiplayer.SendMessageTo(NET_ID, m.CompressedData, m.Target);
-                                break;
-                            case MessageTarget.Server:
-                                MyAPIGateway.Multiplayer.SendMessageToServer(NET_ID, m.CompressedData);
-                                break;
-                            case MessageTarget.AllClients:
-                                MyAPIGateway.Players.GetPlayers(_playerCache);
-                                foreach (var p in _playerCache)
-                                {
-                                    if (p.SteamUserId == MyAPIGateway.Multiplayer.MyId)
-                                        continue;
-                                    MyAPIGateway.Multiplayer.SendMessageTo(NET_ID, m.CompressedData, p.SteamUserId);
-                                }
-
-                                break;
-                            case MessageTarget.AllExcept:
-                                MyAPIGateway.Players.GetPlayers(_playerCache);
-                                foreach (var p in _playerCache)
-                                {
-                                    if (p.SteamUserId == MyAPIGateway.Multiplayer.MyId || m.Ignore.Contains(p.SteamUserId))
-                                        continue;
-                                    MyAPIGateway.Multiplayer.SendMessageTo(NET_ID, m.CompressedData, p.SteamUserId);
-                                }
-
-                                break;
-                            default:
-                                throw new Exception();
-                        }
-
-                        _playerCache.Clear();
-                    }
-                }
-                catch (Exception ex)
-                {
-                    MyLog.Default.WriteLineAndConsole($"TORCH MOD: Exception occurred in communication thread! {ex}");
-                }
-            }
-
-            MyLog.Default.WriteLineAndConsole("TORCH MOD: INFO: Communication thread shut down successfully! THIS IS NOT AN ERROR");
-            //exit signal received. Clean everything and GTFO
-            _processing?.Dispose();
-            _processing = null;
-            _messagePool?.Clean();
-            _messagePool = null;
-            _playerCache = null;
         }
         
         public static void SendMessageTo(MessageBase message, ulong target)
@@ -163,12 +52,7 @@ namespace Torch.Mod
             if (!MyAPIGateway.Multiplayer.IsServer)
                 throw new Exception("Only server can send targeted messages");
 
-            if (_closing)
+            MyAPIGateway.Multiplayer.SendMessageTo(CHANNEL, Serialize(message), target);
-                return;
-
-            message.Target = target;
-            message.TargetType = MessageTarget.Single;
-            _processing.Add(message);
         }
 
         public static void SendMessageToClients(MessageBase message)
@@ -176,11 +60,7 @@ namespace Torch.Mod
             if (!MyAPIGateway.Multiplayer.IsServer)
                 throw new Exception("Only server can send targeted messages");
 
-            if (_closing)
+            MyAPIGateway.Multiplayer.SendMessageToOthers(CHANNEL, Serialize(message));
-                return;
-
-            message.TargetType = MessageTarget.AllClients;
-            _processing.Add(message);
         }
 
         public static void SendMessageExcept(MessageBase message, params ulong[] ignoredUsers)
@@ -188,21 +68,20 @@ namespace Torch.Mod
             if (!MyAPIGateway.Multiplayer.IsServer)
                 throw new Exception("Only server can send targeted messages");
 
-            if (_closing)
+            using var players = Players;
-                return;
+            MyAPIGateway.Multiplayer.Players.GetPlayers(players, player => !ignoredUsers.Contains(player.SteamUserId));
 
-            message.TargetType = MessageTarget.AllExcept;
+            var data = Serialize(message);
-            message.Ignore = ignoredUsers;
+            foreach (var player in players)
-            _processing.Add(message);
+            {
+                MyAPIGateway.Multiplayer.SendMessageTo(CHANNEL, data, player.SteamUserId);
+            }
         }
 
         public static void SendMessageToServer(MessageBase message)
         {
-            if (_closing)
+            throw new NotSupportedException();
-                return;
+        }
-
+#endif
-            message.TargetType = MessageTarget.Server;
-            _processing.Add(message);
-        }
     }
 }

Torch.Mod/Torch.Mod.projitems

@@ -9,13 +9,11 @@
     <Import_RootNamespace>Torch.Mod</Import_RootNamespace>
   </PropertyGroup>
   <ItemGroup>
-    <Compile Include="$(MSBuildThisFileDirectory)Messages\IncomingMessage.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Messages\JoinServerMessage.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Messages\NotificationMessage.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Messages\DialogMessage.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Messages\MessageBase.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Messages\VoxelResetMessage.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ModCommunication.cs" />
-    <Compile Include="$(MSBuildThisFileDirectory)TorchModCore.cs" />
   </ItemGroup>
 </Project>

Torch.Mod/TorchModCore.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Sandbox.ModAPI;
-using VRage.Game.Components;
-
-namespace Torch.Mod
-{
-    [MySessionComponentDescriptor(MyUpdateOrder.AfterSimulation)]
-    public class TorchModCore : MySessionComponentBase
-    {
-        public const ulong MOD_ID = 2722000298;
-        private static bool _init;
-        public static bool Debug;
-
-        public override void UpdateAfterSimulation()
-        {
-            if (_init)
-                return;
-
-            _init = true;
-            ModCommunication.Register();
-            MyAPIGateway.Utilities.MessageEntered += Utilities_MessageEntered;
-        }
-
-        private void Utilities_MessageEntered(string messageText, ref bool sendToOthers)
-        {
-            if (messageText == "@!debug")
-            {
-                Debug = !Debug;
-                MyAPIGateway.Utilities.ShowMessage("Torch", $"Debug: {Debug}");
-                sendToOthers = false;
-            }
-        }
-
-        protected override void UnloadData()
-        {
-            try
-            {
-                MyAPIGateway.Utilities.MessageEntered -= Utilities_MessageEntered;
-                ModCommunication.Unregister();
-            }
-            catch
-            {
-                //session unloading, don't care
-            }
-        }
-    }
-}

Torch.Server.ReferenceAssemblies.net7.nuspec

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
+    <metadata>
+        <id>Torch.Server.ReferenceAssemblies.net7</id>
+        <version>torchVersion</version>
+        <title>Torch Server Reference Assemblies</title>
+        <authors>zznty</authors>
+        <owners>zznty</owners>
+        <requireLicenseAcceptance>false</requireLicenseAcceptance>
+        <description>Torch Server Reference Assemblies (.NET 7 edition)</description>
+        <repository type="git" url="https://github.com/PveTeam/Torch" />
+        <dependencies>
+            <group targetFramework="net7.0-windows7.0">
+                <dependency id="SpaceEngineersDedicated.ReferenceAssemblies" version="1.203.22" />
+                <dependency id="Torch.Server" version="torchVersion" />
+            </group>
+        </dependencies>
+        <frameworkReferences>
+            <group targetFramework="net7.0-windows7.0">
+                <frameworkReference name="Microsoft.WindowsDesktop.App.WPF" />
+            </group>
+        </frameworkReferences>
+    </metadata>
+</package>

Torch.Server.Tests/Torch.Server.Tests.csproj

@@ -17,8 +17,8 @@
   </PropertyGroup>
 <!--   <Import Project="$(SolutionDir)\TransformOnBuild.targets" /> -->
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.3" />
-    <PackageReference Include="NLog" Version="5.1.0" />
+    <PackageReference Include="NLog" Version="5.2.2" />
     <PackageReference Include="xunit" Version="2.4.2" />
   </ItemGroup>
   <ItemGroup>

Torch.Server/Initializer.cs

@@ -16,6 +16,7 @@ using Microsoft.Extensions.Configuration;
 using NLog;
 using NLog.Targets;
 using Sandbox.Engine.Utils;
+using SpaceEngineers.Game;
 using Torch.Utils;
 using VRage.FileSystem;
 
@@ -27,10 +28,10 @@ namespace Torch.Server
 
         private static readonly Logger Log = LogManager.GetLogger(nameof(Initializer));
         private bool _init;
-        private const string STEAMCMD_DIR = "steamcmd";
+        private const string TOOL_DIR = "tool";
-        private const string STEAMCMD_ZIP = "temp.zip";
+        private const string TOOL_ZIP = "temp.zip";
-        private static readonly string STEAMCMD_EXE = "steamcmd.exe";
+        private static readonly string TOOL_EXE = "steamcmd.exe";
-        private const string STEAMCMD_ARGS = "+force_install_dir \"{0}\" +login anonymous +app_update 298740 +quit";
+        private const string TOOL_ARGS = "+force_install_dir \"{0}\" +login anonymous +app_update 298740 +quit";
         private TorchServer _server;
 
         internal Persistent<TorchConfig> ConfigPersistent { get; }
@@ -56,8 +57,8 @@ namespace Torch.Server
             Log.Debug("Debug logging enabled.");
 #endif
             
-            if (!configuration.GetValue("noupdate", false))
+            if (configuration.GetValue("getGameUpdates", true) && !configuration.GetValue("noupdate", false))
-                RunSteamCmd(configuration);
+                RunSteamCmdAsync(configuration).Wait();
 
             var processPid = configuration.GetValue<int>("waitForPid");
             if (processPid != 0)
@@ -83,9 +84,9 @@ namespace Torch.Server
             return true;
         }
 
-        public void Run()
+        public void Run(IConfiguration configuration)
         {
-            _server = new TorchServer(Config, ApplicationContext.Current.InstanceDirectory.FullName, ApplicationContext.Current.InstanceName);
+            _server = new TorchServer(Config, ApplicationContext.Current.InstanceDirectory.FullName, ApplicationContext.Current.InstanceName, configuration);
 
             if (ApplicationContext.Current.IsService || Config.NoGui)
             {
@@ -102,53 +103,56 @@ namespace Torch.Server
                 }
 #endif
                 
-                var gameThread = new Thread(() =>
-                {
                 _server.Init();
                 
-                    if (Config.Autostart || Config.TempAutostart)
+                var uiThread = new Thread(() =>
                 {
-                        Config.TempAutostart = false;
-                        _server.Start();
-                    }
-                });
-                
-                gameThread.Start();
-                
                     var ui = new TorchUI(_server);
                 
                     SynchronizationContext.SetSynchronizationContext(
                         new DispatcherSynchronizationContext(Dispatcher.CurrentDispatcher));
                 
                     ui.ShowDialog();
+                });
+                
+                uiThread.SetApartmentState(ApartmentState.STA);
+                uiThread.Start();
+                
+                if (Config.Autostart || Config.TempAutostart)
+                {
+                    Config.TempAutostart = false;
+                    _server.Start();
+                }
+
+                uiThread.Join();
             }
         }
         
-        public static void RunSteamCmd(IConfiguration configuration)
+        public static async Task RunSteamCmdAsync(IConfiguration configuration)
         {
             var log = LogManager.GetLogger("SteamCMD");
             
-            var path = configuration.GetValue<string>("steamCmdPath") ?? ApplicationContext.Current.TorchDirectory
+            var path = configuration.GetValue<string>("steamToolPath") ?? ApplicationContext.Current.TorchDirectory
-                .CreateSubdirectory(STEAMCMD_DIR).FullName;
+                .CreateSubdirectory(TOOL_DIR).FullName;
 
             if (!Directory.Exists(path))
             {
                 Directory.CreateDirectory(path);
             }
             
-            var steamCmdExePath = Path.Combine(path, STEAMCMD_EXE);
+            var toolExe = Path.Combine(path, TOOL_EXE);
-            if (!File.Exists(steamCmdExePath))
+            if (!File.Exists(toolExe))
             {
                 try
                 {
                     log.Info("Downloading SteamCMD.");
                     using (var client = new HttpClient())
-                    using (var file = File.Create(STEAMCMD_ZIP))
+                    await using (var file = File.Create(TOOL_ZIP))
-                    using (var stream = client.GetStreamAsync("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip").Result)
+                    await using (var stream = await client.GetStreamAsync("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip"))
-                        stream.CopyTo(file);
+                        await stream.CopyToAsync(file);
 
-                    ZipFile.ExtractToDirectory(STEAMCMD_ZIP, path);
+                    ZipFile.ExtractToDirectory(TOOL_ZIP, path);
-                    File.Delete(STEAMCMD_ZIP);
+                    File.Delete(TOOL_ZIP);
                     log.Info("SteamCMD downloaded successfully!");
                 }
                 catch (Exception e)
@@ -159,21 +163,18 @@ namespace Torch.Server
             }
 
             log.Info("Checking for DS updates.");
-            var steamCmdProc = new ProcessStartInfo(steamCmdExePath)
+            var steamCmdProc = new ProcessStartInfo(toolExe)
             {
-                Arguments = string.Format(STEAMCMD_ARGS, configuration.GetValue("gamePath", "../")),
+                Arguments = string.Format(TOOL_ARGS, configuration.GetValue("gamePath", "../")),
                 WorkingDirectory = path,
-                UseShellExecute = false,
+                RedirectStandardOutput = true
-                RedirectStandardOutput = true,
-                StandardOutputEncoding = Encoding.ASCII
             };
-            var cmd = Process.Start(steamCmdProc);
+            var cmd = Process.Start(steamCmdProc)!;
             
-            // ReSharper disable once PossibleNullReferenceException
             while (!cmd.HasExited)
             {
-                log.Info(cmd.StandardOutput.ReadLine());
+                if (await cmd.StandardOutput.ReadLineAsync() is { } line)
-                Thread.Sleep(100);
+                    log.Info(line);
             }
         }
     }

Torch.Server/Managers/InstanceManager.cs

@@ -7,6 +7,7 @@ using System.Linq;
 using System.Reflection;
 using System.Runtime.Serialization;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Havok;
 using NLog;
@@ -27,6 +28,7 @@ using VRage.FileSystem;
 using VRage.Game;
 using VRage.Game.ObjectBuilder;
 using VRage.ObjectBuilders;
+using VRage.ObjectBuilders.Private;
 using VRage.Plugins;
 
 namespace Torch.Server.Managers
@@ -35,7 +37,45 @@ namespace Torch.Server.Managers
     {
         private const string CONFIG_NAME = "SpaceEngineers-Dedicated.cfg";
         
-        public event Action<ConfigDedicatedViewModel> InstanceLoaded;
+        private Action<ConfigDedicatedViewModel> _instanceLoaded;
+
+        /// <summary>
+        /// Gets or sets the instance loaded event.
+        /// </summary>
+        /// <remarks>
+        /// Called when the instance is loaded and immediately if subscribed after the instance is loaded.
+        /// </remarks>
+        public event Action<ConfigDedicatedViewModel> InstanceLoaded
+        {
+            add
+            {
+                var action = _instanceLoaded;
+                Action<ConfigDedicatedViewModel> action2;
+                do
+                {
+                    action2 = action;
+                    var action3 = (Action<ConfigDedicatedViewModel>)Delegate.Combine(action2, value);
+                    action = Interlocked.CompareExchange(ref _instanceLoaded, action3, action2);
+                }
+                while (action != action2);
+
+                if (DedicatedConfig is not null)
+                    value(DedicatedConfig);
+            }
+            remove
+            {
+                var action = _instanceLoaded;
+                Action<ConfigDedicatedViewModel> action2;
+                do
+                {
+                    action2 = action;
+                    var action3 = (Action<ConfigDedicatedViewModel>)Delegate.Remove(action2, value);
+                    action = Interlocked.CompareExchange(ref _instanceLoaded, action3, action2);
+                }
+                while (action != action2);
+            }
+        }
+
         public ConfigDedicatedViewModel DedicatedConfig { get; set; }
         private static readonly Logger Log = LogManager.GetLogger(nameof(InstanceManager));
         [Dependency]
@@ -102,7 +142,7 @@ namespace Torch.Server.Managers
 
             SelectWorld(DedicatedConfig.LoadWorld ?? DedicatedConfig.Worlds.First().WorldPath, false);
 
-            InstanceLoaded?.Invoke(DedicatedConfig);
+            _instanceLoaded?.Invoke(DedicatedConfig);
         }
 
         public void SelectCreatedWorld(string worldPath)
@@ -146,7 +186,7 @@ namespace Torch.Server.Managers
             {
                 DedicatedConfig.Mods.Clear();
                 //remove the Torch mod to avoid running multiple copies of it
-                DedicatedConfig.SelectedWorld.WorldConfiguration.Mods.RemoveAll(m => m.PublishedFileId == TorchModCore.MOD_ID);
+                DedicatedConfig.SelectedWorld.WorldConfiguration.Mods.RemoveAll(m => m.PublishedFileId == ModCommunication.MOD_ID);
                 foreach (var m in DedicatedConfig.SelectedWorld.WorldConfiguration.Mods)
                     DedicatedConfig.Mods.Add(new ModItemInfo(m));
                 Task.Run(() => DedicatedConfig.UpdateAllModInfosAsync());
@@ -161,7 +201,7 @@ namespace Torch.Server.Managers
             {
                 DedicatedConfig.Mods.Clear();
                 //remove the Torch mod to avoid running multiple copies of it
-                DedicatedConfig.SelectedWorld.WorldConfiguration.Mods.RemoveAll(m => m.PublishedFileId == TorchModCore.MOD_ID);
+                DedicatedConfig.SelectedWorld.WorldConfiguration.Mods.RemoveAll(m => m.PublishedFileId == ModCommunication.MOD_ID);
                 foreach (var m in DedicatedConfig.SelectedWorld.WorldConfiguration.Mods)
                     DedicatedConfig.Mods.Add(new ModItemInfo(m));
                 Task.Run(() => DedicatedConfig.UpdateAllModInfosAsync());
@@ -324,10 +364,10 @@ namespace Torch.Server.Managers
         public void SaveSandbox()
         {
             using (var f = File.Open(_checkpointPath, FileMode.Create))
-                MyObjectBuilderSerializer.SerializeXML(f, Checkpoint);
+                MyObjectBuilderSerializerKeen.SerializeXML(f, Checkpoint);
 
             using (var f = File.Open(_worldConfigPath, FileMode.Create))
-                MyObjectBuilderSerializer.SerializeXML(f, WorldConfiguration);
+                MyObjectBuilderSerializerKeen.SerializeXML(f, WorldConfiguration);
         }
 
         public void LoadSandbox()

Torch.Server/Managers/RemoteAPIManager.cs

@@ -32,7 +32,7 @@ namespace Torch.Server.Managers
         {
             if (newstate == TorchGameState.Loading && MySandboxGame.ConfigDedicated.RemoteApiEnabled && !string.IsNullOrEmpty(MySandboxGame.ConfigDedicated.RemoteSecurityKey))
             {
-                var myRemoteServer = new MyRemoteServer(MySandboxGame.ConfigDedicated.RemoteApiPort, MySandboxGame.ConfigDedicated.RemoteSecurityKey);
+                var myRemoteServer = new MyRemoteServer(MySandboxGame.ConfigDedicated.RemoteApiIP, MySandboxGame.ConfigDedicated.RemoteApiPort, MySandboxGame.ConfigDedicated.RemoteSecurityKey);
                 LogManager.GetCurrentClassLogger().Info($"Remote API started on port {myRemoteServer.Port}");
             }
         }

Torch.Server/Program.cs

@@ -12,7 +12,7 @@ namespace Torch.Server
 {
     internal static class Program
     {
-        [STAThread]
+        [MTAThread]
         public static void Main(string[] args)
         {
             var configurationBuilder = new ConfigurationBuilder()
@@ -39,7 +39,7 @@ namespace Torch.Server
                 context.GameBinariesDirectory.FullName);
 #endif
 
-            initializer.Run();
+            initializer.Run(configuration);
         }
 
         private static void SetupLogging(IApplicationContext context, IConfiguration configuration)

Torch.Server/Torch.Server.csproj

@@ -34,24 +34,23 @@
   <ItemGroup>
     <PackageReference Include="AutoCompleteTextBox" Version="1.6.0" />
     <PackageReference Include="Ben.Demystifier" Version="0.4.1" />
-    <PackageReference Include="ControlzEx" Version="5.0.2" />
+    <PackageReference Include="ControlzEx" Version="6.0.0" />
     <PackageReference Include="MahApps.Metro" Version="2.4.9" />
-    <PackageReference Include="MdXaml" Version="1.16.2" />
+    <PackageReference Include="MdXaml" Version="1.20.1" />
-    <PackageReference Include="Microsoft.Diagnostics.Runtime" Version="2.2.343001" />
+    <PackageReference Include="Microsoft.Diagnostics.Runtime" Version="2.4.416101" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration.CommandLine" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="7.0.0" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Xml" Version="7.0.0" />
-    <PackageReference Include="NLog" Version="5.1.0" />
+    <PackageReference Include="NLog" Version="5.2.2" />
-    <PackageReference Include="PropertyChanged.Fody" Version="4.0.3" PrivateAssets="all" />
+    <PackageReference Include="PropertyChanged.Fody" Version="4.1.0" PrivateAssets="all" />
     <PackageReference Include="Steamworks.NET" Version="20.1.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>compile</IncludeAssets>
     </PackageReference>
     <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
-    <PackageReference Include="System.Management" Version="7.0.0" />
+    <PackageReference Include="System.Management" Version="7.0.2" />
-    <PackageReference Include="nulastudio.NetCoreBeauty" Version="1.2.9.3" />
+    <PackageReference Include="nulastudio.NetCoreBeauty" Version="1.2.9.5" />
-    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.201.13">
+    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.203.22">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>compile</IncludeAssets>
     </PackageReference>

Torch.Server/TorchConfig.cs

@@ -119,6 +119,9 @@ public class TorchConfig : ViewModel, ITorchConfig
         SourceType = UpdateSourceType.Github
     };
 
+    [Display(Name = "Packages", Description = "Packages to install and use.", GroupName = "Server")]
+    public List<string> Packages { get; set; } = new();
+
     // for backward compatibility
     public void Save(string path = null) => Initializer.Instance?.ConfigPersistent?.Save(path);
 }

Torch.Server/TorchServer.cs

@@ -3,12 +3,12 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Text;
 using System.Threading;
-using System.Threading.Tasks;
 using Microsoft.Diagnostics.Runtime;
+using Microsoft.Extensions.Configuration;
 using NLog;
 using PropertyChanged;
 using Sandbox;
@@ -21,8 +21,6 @@ using Torch.API.Session;
 using Torch.Commands;
 using Torch.Managers.PatchManager;
 using Torch.Mod;
-using Torch.Mod.Messages;
-using Torch.Patches;
 using Torch.Server.Commands;
 using Torch.Server.Managers;
 using Torch.Utils;
@@ -49,8 +47,9 @@ namespace Torch.Server
 
         //Here to trigger rebuild
         /// <inheritdoc />
-        public TorchServer(ITorchConfig config, string instancePath, string instanceName) : base(config)
+        public TorchServer(ITorchConfig config, string instancePath, string instanceName, IConfiguration configuration) : base(config)
         {
+            Configuration = configuration;
             InstancePath = instancePath;
             InstanceName = instanceName;
             DedicatedInstance = new InstanceManager(this);
@@ -60,7 +59,7 @@ namespace Torch.Server
             AddManager(new RemoteAPIManager(this));
 
             var sessionManager = Managers.GetManager<ITorchSessionManager>();
-            sessionManager.AddFactory(x => new MultiplayerManagerDedicated(this));
+            sessionManager.AddFactory(_ => new MultiplayerManagerDedicated(this));
             sessionManager.SessionStateChanged += OnSessionStateChanged;
             
             // Needs to be done at some point after MyVRageWindows.Init
@@ -70,6 +69,14 @@ namespace Torch.Server
             
             _simUpdateTimer.Elapsed += SimUpdateElapsed;
             _simUpdateTimer.Start();
+
+            Console.CancelKeyPress += (_, _) =>
+            {
+                if (State == ServerState.Running)
+                    Stop();
+                
+                Environment.Exit(0);
+            };
         }
 
         private void SimUpdateElapsed(object sender, System.Timers.ElapsedEventArgs e)
@@ -122,7 +129,38 @@ namespace Torch.Server
         /// <inheritdoc />
         public ServerState State { get; private set; }
 
-        public event Action<ITorchServer> Initialized;
+        private Action<ITorchServer> _initializedEvent;
+
+        public event Action<ITorchServer> Initialized
+        {
+            add
+            {
+                var action = _initializedEvent;
+                Action<ITorchServer> action2;
+                do
+                {
+                    action2 = action;
+                    var action3 = (Action<ITorchServer>)Delegate.Combine(action2, value);
+                    action = Interlocked.CompareExchange(ref _initializedEvent, action3, action2);
+                }
+                while (action != action2);
+
+                if (GetManager<InstanceManager>().DedicatedConfig != null)
+                    value(this); //if already initialized
+            }
+            remove
+            {
+                var action = _initializedEvent;
+                Action<ITorchServer> action2;
+                do
+                {
+                    action2 = action;
+                    var action3 = (Action<ITorchServer>)Delegate.Remove(action2, value);
+                    action = Interlocked.CompareExchange(ref _initializedEvent, action3, action2);
+                }
+                while (action != action2);
+            }
+        }
 
         public int OnlinePlayers { get; private set; }
 
@@ -133,10 +171,12 @@ namespace Torch.Server
             base.Init();
             GetManager<InstanceManager>().LoadInstance(InstancePath);
             CanRun = true;
-            Initialized?.Invoke(this);
+            _initializedEvent?.Invoke(this);
             Log.Info($"Initialized server '{InstanceName}' at '{InstancePath}'");
         }
 
+        public override IConfiguration Configuration { get; }
+
         /// <inheritdoc />
         public override void Start()
         {
@@ -207,11 +247,16 @@ namespace Torch.Server
                 StopInternal();
                 LogManager.Flush();
                 
+                if (
 #if DEBUG
-                Environment.Exit(0);
+                    // ReSharper disable once ConditionIsAlwaysTrueOrFalse
+                    true ||
 #endif
+                    ApplicationContext.Current.IsService
+                    )
+                    Environment.Exit(0);
 
-                var exe = Assembly.GetExecutingAssembly().Location.Replace("dll", "exe");
+                var exe = Path.Combine(AppContext.BaseDirectory, "Torch.Server.exe");
 
                 var args = Environment.GetCommandLineArgs();
 
@@ -229,6 +274,8 @@ namespace Torch.Server
                 }
 
                 Process.Start(exe, $"--waitForPid {Environment.ProcessId} --tempAutostart true {string.Join(" ", args)}");
+                
+                Environment.Exit(0);
             })
             {
                 Name = "Restart thread"
@@ -243,14 +290,12 @@ namespace Torch.Server
                 case TorchSessionState.Unloading:
                     _watchdog?.Dispose();
                     _watchdog = null;
-                    ModCommunication.Unregister();
                     break;
                 case TorchSessionState.Loaded:
                     _multiplayerManagerDedicated = CurrentSession.Managers.GetManager<MultiplayerManagerDedicated>();
                     _multiplayerManagerDedicated.PlayerJoined += MultiplayerManagerDedicatedOnPlayerJoined;
                     _multiplayerManagerDedicated.PlayerLeft += MultiplayerManagerDedicatedOnPlayerLeft;
                     CurrentSession.Managers.GetManager<CommandManager>().RegisterCommandModule(typeof(WhitelistCommands));
-                    ModCommunication.Register();
                     break;
                 case TorchSessionState.Loading:
                 case TorchSessionState.Unloaded:

Torch.Server/UnhandledExceptionHandler.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.IO;
 using System.Threading;
 using NLog;
 using VRage;
@@ -31,9 +32,25 @@ internal class UnhandledExceptionHandler
         {
             Console.WriteLine("Restarting in 5 seconds.");
             Thread.Sleep(5000);
-            var exe = typeof(Program).Assembly.Location;
             
-            Process.Start(exe, $"-waitForPid {Environment.ProcessId} {_config}");
+            var exe = Path.Combine(AppContext.BaseDirectory, "Torch.Server.exe");
+
+            var args = Environment.GetCommandLineArgs();
+
+            for (var i = 0; i < args.Length; i++)
+            {
+                if (args[i].Contains(' '))
+                    args[i] = $"\"{args[i]}\"";
+                    
+                if (!args[i].Contains("--tempAutostart", StringComparison.InvariantCultureIgnoreCase) &&
+                    !args[i].Contains("--waitForPid", StringComparison.InvariantCultureIgnoreCase)) 
+                    continue;
+                    
+                args[i] = string.Empty;
+                args[++i] = string.Empty;
+            }
+
+            Process.Start(exe, $"--waitForPid {Environment.ProcessId} --tempAutostart true {string.Join(" ", args)}");
         }
         else
         {

Torch.Server/Views/TorchUI.xaml.cs

@@ -116,7 +116,7 @@ namespace Torch.Server
             if (_server?.State == ServerState.Running)
                 _server.Stop();
 
-            Process.GetCurrentProcess().Kill();
+            Environment.Exit(0);
         }
     }
 }

Torch.Server/packages.lock.json

@@ -19,12 +19,12 @@
       },
       "ControlzEx": {
         "type": "Direct",
-        "requested": "[5.0.2, )",
+        "requested": "[6.0.0, )",
-        "resolved": "5.0.2",
+        "resolved": "6.0.0",
-        "contentHash": "f724LoDJ36LxaLR62G4ek9ZAJI8BiiYRJJ04furC/qjXSeIwU0qmHFIe19xB1/FwxyZjevdFguEr9ZUjf3dZgw==",
+        "contentHash": "MEaqj6ienvKR4E7QJ3vwzo2vrdy2Kqw9Z3CudY5iUixR5iMYeLoMlks7EiABsz4WqDsgVLd9u7fixmCOGU+4ow==",
         "dependencies": {
-          "Microsoft.Xaml.Behaviors.Wpf": "1.1.31",
+          "Microsoft.Xaml.Behaviors.Wpf": "1.1.39",
-          "System.Text.Json": "5.0.1"
+          "System.Text.Json": "5.0.2"
         }
       },
       "MahApps.Metro": {
@@ -38,34 +38,25 @@
       },
       "MdXaml": {
         "type": "Direct",
-        "requested": "[1.16.2, )",
+        "requested": "[1.20.1, )",
-        "resolved": "1.16.2",
+        "resolved": "1.20.1",
-        "contentHash": "UxYWJaXugQ+v4txS7K8sw26bxS6xvjSW+f79U/oMBtm+cVvZSmBGRZkB77rzaoXAyrbixX0Vk0U+1f22TT2uWg==",
+        "contentHash": "fx64BBFK7yO2MHBxMAMV4/b3x24rQ7Gfn64CISaw4dS7Wvr0HGc4vHNyrMY+/CgEpOEATLVgtM1a9liQ+QOesA==",
         "dependencies": {
           "AvalonEdit": "6.0.0",
-          "MdXaml.Plugins": "1.16.2"
+          "MdXaml.Plugins": "1.20.1"
         }
       },
       "Microsoft.Diagnostics.Runtime": {
         "type": "Direct",
-        "requested": "[2.2.343001, )",
+        "requested": "[2.4.416101, )",
-        "resolved": "2.2.343001",
+        "resolved": "2.4.416101",
-        "contentHash": "nVwXLEJiXbnnNkQPcWy64DMWNBvMg9XKWpfBBNMVs1gbEJ9HUVTcAA862mOjgyKryAtvGVKkeQ/9cW6pK8YAiA==",
+        "contentHash": "BUGBGNmjLWnRJ+Oqj23aDKjulOqDk6q62oQzeg9FghfphhhuTwlNLGHV88vKKldx+NHjWUzF3eUPUFxhROrcyQ==",
         "dependencies": {
           "Microsoft.Diagnostics.NETCore.Client": "0.2.251802",
           "System.Collections.Immutable": "5.0.0",
           "System.Runtime.CompilerServices.Unsafe": "5.0.0"
         }
       },
-      "Microsoft.Extensions.Configuration.Binder": {
-        "type": "Direct",
-        "requested": "[7.0.0, )",
-        "resolved": "7.0.0",
-        "contentHash": "tgU4u7bZsoS9MKVRiotVMAwHtbREHr5/5zSEV+JPhg46+ox47Au84E3D2IacAaB0bk5ePNaNieTlPrfjbbRJkg==",
-        "dependencies": {
-          "Microsoft.Extensions.Configuration.Abstractions": "7.0.0"
-        }
-      },
       "Microsoft.Extensions.Configuration.CommandLine": {
         "type": "Direct",
         "requested": "[7.0.0, )",
@@ -101,30 +92,30 @@
       },
       "NLog": {
         "type": "Direct",
-        "requested": "[5.1.0, )",
+        "requested": "[5.2.2, )",
-        "resolved": "5.1.0",
+        "resolved": "5.2.2",
-        "contentHash": "oW7ekrkRG9okpDMUcEglunWj8Qf2RY8qkgl+/chJoavzg3dbT13y32t19R54FKkmq80fKzw4ZekZkCrRGanKgQ=="
+        "contentHash": "r6Q9740g29gTwmTWlsgdIFm0mhNsfNZmbvWKX/Fxmi8X89ZrpUowHM2T2X1lP7RVpND+ef+XnfKL5g6Q1iNGXA=="
       },
       "nulastudio.NetCoreBeauty": {
         "type": "Direct",
-        "requested": "[1.2.9.3, )",
+        "requested": "[1.2.9.5, )",
-        "resolved": "1.2.9.3",
+        "resolved": "1.2.9.5",
-        "contentHash": "ToUOoX/sNCg6oeMcSrHYBBRPjKp1gDS7I5WNnY+59t7iNFPcAojpc2lYmgCm3hxwXW/xCxyQIV4k5agegqc3fg=="
+        "contentHash": "0w2QtE3ir6z9J4fZpW1s3/V93dnceUmVm/E1ADhbt0WJ8z1Q3UhYe0Z7rXCy7Pl3y+zRQwERSV9N0aBuGABLjw=="
       },
       "PropertyChanged.Fody": {
         "type": "Direct",
-        "requested": "[4.0.3, )",
+        "requested": "[4.1.0, )",
-        "resolved": "4.0.3",
+        "resolved": "4.1.0",
-        "contentHash": "vRxEDydahhcetswKaoUug7mQywgpZpHoeHZWa7Opb+H+eWPUQo+f+v37Jy+rrG1RVOCkyziTgCkNetXzNlUXJw==",
+        "contentHash": "6v+f9cI8YjnZH2WBHuOqWEAo8DFFNGFIdU8xD3AsL6fhV6Y8oAmVWd7XKk49t8DpeUBwhR/X+97+6Epvek0Y3A==",
         "dependencies": {
-          "Fody": "6.6.3"
+          "Fody": "6.6.4"
         }
       },
       "SpaceEngineersDedicated.ReferenceAssemblies": {
         "type": "Direct",
-        "requested": "[1.201.13, )",
+        "requested": "[1.203.22, )",
-        "resolved": "1.201.13",
+        "resolved": "1.203.22",
-        "contentHash": "FRXuNLENsz5jGQvL0QkogAGsxEJyUQlXhvWHBWfZiHCnCrAWMD60nEis6yt0xCQpazszfMtHonbxz72XMxnFoQ==",
+        "contentHash": "ruf6DT1sAh2DnpsJUsGG4ZSdPKrVr5ReKfHSDcYggeacge/nsdqpcij53HSNwnMxve6cfnTRG9SXE2iGSGEtEQ==",
         "dependencies": {
           "protobuf-net": "1.0.0"
         }
@@ -143,9 +134,9 @@
       },
       "System.Management": {
         "type": "Direct",
-        "requested": "[7.0.0, )",
+        "requested": "[7.0.2, )",
-        "resolved": "7.0.0",
+        "resolved": "7.0.2",
-        "contentHash": "A4jed4QUviDOm7fJNKAJObEAEkEUXmkGL/w0iyCYTzrl1rezTj8LGFHfsVst4Vb9JwFcTpboiDrvdST48avBpw==",
+        "contentHash": "/qEUN91mP/MUQmJnM5y5BdT7ZoPuVrtxnFlbJ8a3kBJGhe2wCzBfnPFtK2wTtEEcf3DMGR9J00GZZfg6HRI6yA==",
         "dependencies": {
           "System.CodeDom": "7.0.0"
         }
@@ -157,17 +148,15 @@
       },
       "Fody": {
         "type": "Transitive",
-        "resolved": "6.6.3",
+        "resolved": "6.6.4",
-        "contentHash": "X1WKKgSNYVtLzdO8dK3YWmfmljA4L0soePcWNouq9X6WbVF4bmivuJdlhTZx/2L3ml6tMvhFe8skIbVQ24PAYA=="
+        "contentHash": "vLZS+oa+ndUHYPlx/8n9bBTT3dHkCF0riml4paKq4D663+cZd47x1uagQo32D/gKFZ/sfmV1oqKaLmH0elxq4A=="
       },
       "HarmonyX": {
         "type": "Transitive",
-        "resolved": "2.10.2-prerelease.1",
+        "resolved": "2.10.2-prerelease.6",
-        "contentHash": "5hbH0ENhQ+JV7tk63fQ2ab7MtplRHKJYH1JfIjG39rlltHNXxAcGJh05an+SQbVRV4EoP/+Qm9w9BrLc3RwRMA==",
+        "contentHash": "CPCUR/t5AQ5DDs40bTJ5OwUVTCoZONaJGbWKKjAOwg7c7Ct4KEbfybH6T+KvRGVjf5eN1oyGY5BN7EfWxUh9Xg==",
         "dependencies": {
-          "MonoModReorg.RuntimeDetour": "22.11.21-prerelease.2",
+          "MonoMod.RuntimeDetour": "25.0.0"
-          "System.Reflection.Emit": "4.7.0",
-          "System.Reflection.Emit.Lightweight": "4.7.0"
         }
       },
       "JorgeSerrano.Json.JsonSnakeCaseNamingPolicy": {
@@ -177,39 +166,37 @@
       },
       "MdXaml.Plugins": {
         "type": "Transitive",
-        "resolved": "1.16.2",
+        "resolved": "1.20.1",
-        "contentHash": "EOMENHbLkpRk7+UItuutDuETiJpSCZgBATBRk7WSuxO16NUfzrS39ja4RhIQ0Ax8u0RH1wCAS0VINYPZqxfJeg=="
+        "contentHash": "+pLkHJ8LuTVdZ0FM5c9ftjaebN4L7I4ShhXideTSos8rfULFSzLFuBWZot22A9yljuEpn5FbPw04Jrrs/il9ng=="
       },
       "Microsoft.Bcl.AsyncInterfaces": {
         "type": "Transitive",
-        "resolved": "1.1.0",
+        "resolved": "6.0.0",
-        "contentHash": "1Am6l4Vpn3/K32daEqZI+FFr96OlZkgwK2LcT3pZ2zWubR5zTPW3/FkO1Rat9kb7oQOa4rxgl9LJHc5tspCWfg=="
+        "contentHash": "UcSjPsst+DfAdJGVDsu346FX0ci0ah+lw3WRtn18NUwEqRt70HaOQ7lI72vy3+1LxtqI3T5GWwV39rQSrCzAeg=="
       },
       "Microsoft.CodeAnalysis.Analyzers": {
         "type": "Transitive",
-        "resolved": "3.3.3",
+        "resolved": "3.3.4",
-        "contentHash": "j/rOZtLMVJjrfLRlAMckJLPW/1rze9MT1yfWqSIbUPGRu1m1P0fuo9PmqapwsmePfGB5PJrudQLvmUOAMF0DqQ=="
+        "contentHash": "AxkxcPR+rheX0SmvpLVIGLhOUXAKG56a64kV9VQZ4y9gR9ZmPXnqZvHJnmwLSwzrEP6junUF11vuc+aqo5r68g=="
       },
       "Microsoft.CodeAnalysis.Common": {
         "type": "Transitive",
-        "resolved": "4.4.0",
+        "resolved": "4.6.0",
-        "contentHash": "JfHupS/B7Jb5MZoYkFFABn3mux0wQgxi2D8F/rJYZeRBK2ZOyk7TjQ2Kq9rh6W/DCh0KNbbSbn5qoFar+ueHqw==",
+        "contentHash": "N3uLvekc7DjvE1BX8YW7UH7ldjA4ps/Tun2YmOoSIItJrh1gnQIMKUbK1c3uQUx2NHbLibVZI4o/VB9xb4B7tA==",
         "dependencies": {
-          "Microsoft.CodeAnalysis.Analyzers": "3.3.3",
+          "Microsoft.CodeAnalysis.Analyzers": "3.3.4",
-          "System.Collections.Immutable": "6.0.0",
+          "System.Collections.Immutable": "7.0.0",
-          "System.Memory": "4.5.5",
+          "System.Reflection.Metadata": "7.0.0",
-          "System.Reflection.Metadata": "5.0.0",
           "System.Runtime.CompilerServices.Unsafe": "6.0.0",
-          "System.Text.Encoding.CodePages": "6.0.0",
+          "System.Text.Encoding.CodePages": "7.0.0"
-          "System.Threading.Tasks.Extensions": "4.5.4"
         }
       },
       "Microsoft.CodeAnalysis.CSharp": {
         "type": "Transitive",
-        "resolved": "4.4.0",
+        "resolved": "4.6.0",
-        "contentHash": "eD2w0xHRoaqK07hjlOKGR9eLNy3nimiGNeCClNax1NDgS/+DBtBqCjXelOa+TNy99kIB3nHhUqDmr46nDXy/RQ==",
+        "contentHash": "9pyFZUN2Lyu3C0Xfs49kezfH+CzQHMibGsQeQPu0P+GWyH2XXDwmyZ6jAaKQGNUXOJfC2OK01hWMJTJY315uDQ==",
         "dependencies": {
-          "Microsoft.CodeAnalysis.Common": "[4.4.0]"
+          "Microsoft.CodeAnalysis.Common": "[4.6.0]"
         }
       },
       "Microsoft.Diagnostics.NETCore.Client": {
@@ -238,6 +225,14 @@
           "Microsoft.Extensions.Primitives": "7.0.0"
         }
       },
+      "Microsoft.Extensions.Configuration.Binder": {
+        "type": "Transitive",
+        "resolved": "7.0.4",
+        "contentHash": "8+XPvJnHZsYgHOQlcMuQe7QNF5KdVKHH1F/wW3nd8/u81Gk/XFAYMDP0Lpz18h7/AM95M662vvqMorcYxCBB4w==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "7.0.0"
+        }
+      },
       "Microsoft.Extensions.Configuration.FileExtensions": {
         "type": "Transitive",
         "resolved": "7.0.0",
@@ -310,72 +305,173 @@
       },
       "Microsoft.Xaml.Behaviors.Wpf": {
         "type": "Transitive",
-        "resolved": "1.1.31",
+        "resolved": "1.1.39",
-        "contentHash": "LZpuf82ACZWldmfMuv3CTUMDh3o0xo0uHUaybR5HgqVLDBJJ9RZLykplQ/bTJd0/VDt3EhD4iDgUgbdIUAM+Kg=="
+        "contentHash": "8PZKqw9QOcu42xk8puY4P1+EXHL9YGOR9b7qhaYx5cILHul456H073tj99vyPcCt0W0781T9RwHqkx507ZyUpQ=="
       },
       "Mono.Cecil": {
         "type": "Transitive",
         "resolved": "0.11.4",
         "contentHash": "IC1h5g0NeJGHIUgzM1P82ld57knhP0IcQfrYITDPXlNpMYGUrsG5TxuaWTjaeqDNQMBDNZkB8L0rBnwsY6JHuQ=="
       },
-      "MonoModReorg.Backports": {
+      "MonoMod.Backports": {
         "type": "Transitive",
-        "resolved": "22.11.21-prerelease.2",
+        "resolved": "1.0.0",
-        "contentHash": "69T6jjA5nx29jLkdqtfXKlJ8sMqIlc6czNDTomy0rbM68W0xo2JRJBgsu2mroBuqx7nvUdX+zIU6k1edS/pPbw==",
+        "contentHash": "J59I4CMe24aCmWboHCDzQIk37kXqHnJH6KQfDGstlznuDni7Lwdd/8CywmEwVXjVEgfs5yQzvOTW3Xg1NH7fDQ==",
         "dependencies": {
-          "MonoModReorg.ILHelpers": "22.11.21-prerelease.2"
+          "MonoMod.ILHelpers": "1.0.0"
         }
       },
-      "MonoModReorg.Core": {
+      "MonoMod.Core": {
         "type": "Transitive",
-        "resolved": "22.11.21-prerelease.2",
+        "resolved": "1.0.0",
-        "contentHash": "gDoxu4aAF6TeOo8rsrj5prq2X36i12ch6NeRHu/Ct0H3qoPDHuEQ6JMJN/Eiy45YrLNEN7C5+Ku4BrNX4nwVQg==",
+        "contentHash": "FlzAEa4ujbA1t3rbKxuW3DP36T0/L6k2IP1F4QXM1cOXMJLHm39Azjt98E/9LFRFBWYFdlMUmg+4THLv2xyisA==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "22.11.21-prerelease.2",
+          "MonoMod.Backports": "1.0.0",
-          "MonoModReorg.ILHelpers": "22.11.21-prerelease.2",
+          "MonoMod.ILHelpers": "1.0.0",
-          "MonoModReorg.Utils": "22.11.21-prerelease.2"
+          "MonoMod.Utils": "25.0.0"
         }
       },
-      "MonoModReorg.ILHelpers": {
+      "MonoMod.ILHelpers": {
         "type": "Transitive",
-        "resolved": "22.11.21-prerelease.2",
+        "resolved": "1.0.0",
-        "contentHash": "JtOKHJR4DEyq3HxmdEVXIxhqNQnu1KmjGFXuEQrNHoPbzi8Yr9465VKVXdsoAF0Lm8StdyJHQ03efjv3+OlonA=="
+        "contentHash": "dTjGA+dYl7W5yQ0oG/Wr57tsa+ueoFUrwPtz9MZF9iheun4n70u7lge52F8UJi9i0zMHRfS2mAY6+nPuRZHQyQ=="
       },
-      "MonoModReorg.RuntimeDetour": {
+      "MonoMod.RuntimeDetour": {
         "type": "Transitive",
-        "resolved": "22.11.21-prerelease.2",
+        "resolved": "25.0.0",
-        "contentHash": "Qv1h4rW03LrHwxwVuw5R6hbL8X78l8Lfnxe5tMlyVAe+AK0HnwsRzjsTwzFF57wxWUwq12NbLflkzV6T+hIhJw==",
+        "contentHash": "u+G34uSEjU0+fk4Iz3Mfws/+E4kW460i6fBz1b4L/yxSndfmdKkJ+pYbU9pwh7IUxgk0Ko0+Mx3fSUQPaNk8nA==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "22.11.21-prerelease.2",
+          "MonoMod.Backports": "1.0.0",
-          "MonoModReorg.Core": "22.11.21-prerelease.2",
+          "MonoMod.Core": "1.0.0",
-          "MonoModReorg.ILHelpers": "22.11.21-prerelease.2",
+          "MonoMod.ILHelpers": "1.0.0",
-          "MonoModReorg.Utils": "22.11.21-prerelease.2"
+          "MonoMod.Utils": "25.0.0"
         }
       },
-      "MonoModReorg.Utils": {
+      "MonoMod.Utils": {
         "type": "Transitive",
-        "resolved": "22.11.21-prerelease.2",
+        "resolved": "25.0.0",
-        "contentHash": "TX+vlgg2/x8rzEOqwiAy2qv61FjlJsr4u10WGTekCkulZVmmC+xxDmK+4Do9noXF/4RlgFN6sR3m9/W8KvJq3g==",
+        "contentHash": "E8m0pH3Kact+A2qH+lxMis90K8+ixInwprn0R1nuAMRHfotHUHeYmr304UEPeInSuY3+IlnC+OB8fqbQiTsWlQ==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "22.11.21-prerelease.2",
+          "MonoMod.Backports": "1.0.0",
-          "MonoModReorg.ILHelpers": "22.11.21-prerelease.2"
+          "MonoMod.ILHelpers": "1.0.0"
         }
       },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.1",
+        "contentHash": "ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A=="
+      },
+      "NuGet.Commands": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "D1b7gTk1wp7sxscLhS8O/yoErsRVbR4zJvLVD4jo1sgxh42ZOWKpMkhznPUxpvmCxBhw9hAy8/yWrRH91SfdEQ==",
+        "dependencies": {
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileSystemGlobbing": "6.0.0",
+          "NuGet.Credentials": "6.6.1",
+          "NuGet.ProjectModel": "6.6.1"
+        }
+      },
+      "NuGet.Common": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "hW5NtShErO3qbdkyv7doCRsFNK9Rlcc7mVjYM+hg1sOAWheTh/oo95DzNbsZthiqyHZfaioopfWtzmoxNw9h4g==",
+        "dependencies": {
+          "NuGet.Frameworks": "6.6.1"
+        }
+      },
+      "NuGet.Configuration": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "9WbK8wgwPfRpSwuG+ZhMshE48qUYvPIw7VNLCncrq/in4vE6SGsuawPSxPJkkLBtcKTGbPMez5JDvUf6vEBgKg==",
+        "dependencies": {
+          "NuGet.Common": "6.6.1",
+          "System.Security.Cryptography.ProtectedData": "4.4.0"
+        }
+      },
+      "NuGet.Credentials": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "TuOlXcE1ajwdtfnQaUjDv2xO2u/WDS56/b5jHfEBZetKfcpT0W3iNOqInVPO0qxRxXK5/HXUKVr2Pya1LsVVnA==",
+        "dependencies": {
+          "NuGet.Protocol": "6.6.1"
+        }
+      },
+      "NuGet.DependencyResolver.Core": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "K+EXXLU37PBnwLGx6WnVGxlfWYkdedvUUOeDMERXelNgjg20irtKf3hk+wGB7NmxAdNY9/gGcOgSDOV+M0w3Jg==",
+        "dependencies": {
+          "NuGet.Configuration": "6.6.1",
+          "NuGet.LibraryModel": "6.6.1",
+          "NuGet.Protocol": "6.6.1"
+        }
+      },
+      "NuGet.Frameworks": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "iRtDhL0zPqVw037fHEK9bQljTKPuOHhfIkz86/IH2P8eetr910HTTe5G8lJTuzZHh592Ze/sYhh173HIFjPSfg=="
+      },
+      "NuGet.LibraryModel": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "B0KH19sNNUq56YfEozIsIpk8EOyolG0LRT+hqG1/mhuXlQFiP9BgT6pZgwLQVLUl9YBDx3+KWQQbl6pz8Yh/Sw==",
+        "dependencies": {
+          "NuGet.Common": "6.6.1",
+          "NuGet.Versioning": "6.6.1"
+        }
+      },
+      "NuGet.Packaging": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "GwhFi2Ep4YzAGQFYz1OsMVNfiJ1M46nyCgHQ7xjJSMvxDYFgodR1RqVugWFMbIUUq6I8iYASwp5lpHXvITeuIQ==",
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "NuGet.Configuration": "6.6.1",
+          "NuGet.Versioning": "6.6.1",
+          "System.Security.Cryptography.Cng": "5.0.0",
+          "System.Security.Cryptography.Pkcs": "5.0.0"
+        }
+      },
+      "NuGet.ProjectModel": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "CEyRXXvgIoEQBWn3WZupjkIVC6rPcGUAO5p4Gz+fnF8kcefWQOXHfnOE+UKZ0WwAJG5iMWRvXBKAGOuFiFhNpQ==",
+        "dependencies": {
+          "NuGet.DependencyResolver.Core": "6.6.1"
+        }
+      },
+      "NuGet.Protocol": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "HhKLsK6Q0NNp6qb0T26GLR5gCTRZu+gzqDVK4xqXHZmsolaDVIdIYpn44b2etaVYLzNJCvgRkw+I422u2bIvMw==",
+        "dependencies": {
+          "NuGet.Packaging": "6.6.1"
+        }
+      },
+      "NuGet.Versioning": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "Wm/AOFICTIrCgbVxv9dNWusraTzcggbo5W4ao7hD8NNVq911an9TGwW+uNuYc8I5PkpTeMuSXneV2u6hbi1P4w=="
+      },
       "protobuf-net": {
         "type": "Transitive",
-        "resolved": "3.1.26",
+        "resolved": "3.2.26",
-        "contentHash": "iy+VROYtWZEqDvkUjS6FfzKZNpWRoVGc5h0cupGQT/37Ox0LxPblRKLnw6V0RT1MPclLo8nZp7E2M0f7PNn/Tw==",
+        "contentHash": "zBzBiKs4yP+tzQOsRA5WbI/zayS6eFv8g0KIKNPI7/RUY1nk9Oe+STmtbUYkNUkO3T3SidEoZv+tF1nmgTSutQ==",
         "dependencies": {
-          "protobuf-net.Core": "3.1.26"
+          "protobuf-net.Core": "3.2.26"
         }
       },
       "protobuf-net.Core": {
         "type": "Transitive",
-        "resolved": "3.1.26",
+        "resolved": "3.2.26",
-        "contentHash": "fuKoDWgAf5ju+ixbJoasVFhnUaT0oWUgrWh1AZ5D0Y5keKHpA93vQB5g6aQNtB4zgeQ4hGEeh0MY9bIbAUPgEw=="
+        "contentHash": "s8oJW9dBVxix4p8uqMbeG++DIGjgzOFAKoP2i5wayeeFOKBqG+cCBO2S/CAC4MAFlb5m1Os2m/miLcqRCgqJ7Q==",
+        "dependencies": {
+          "System.Collections.Immutable": "7.0.0"
+        }
       },
       "SemanticVersioning": {
         "type": "Transitive",
@@ -397,42 +493,43 @@
       },
       "System.Collections.Immutable": {
         "type": "Transitive",
-        "resolved": "6.0.0",
+        "resolved": "7.0.0",
-        "contentHash": "l4zZJ1WU2hqpQQHXz1rvC3etVZN+2DLmQMO79FhOTZHMn8tDRr+WU287sbomD0BETlmKDn0ygUgVy9k5xkkJdA==",
+        "contentHash": "dQPcs0U1IKnBdRDBkrCTi1FoajSTBzLcVTpjO4MBCMC7f4pDOIPzgBoX8JjG7X6uZRJ8EBxsi8+DR1JuwjnzOQ=="
-        "dependencies": {
-          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
-        }
       },
       "System.Formats.Asn1": {
         "type": "Transitive",
         "resolved": "7.0.0",
         "contentHash": "+nfpV0afLmvJW8+pLlHxRjz3oZJw4fkyU9MMEaMhCsHi/SN9bGF9q79ROubDiwTiCHezmK0uCWkPP7tGFP/4yg=="
       },
-      "System.Memory": {
+      "System.Linq.Async": {
         "type": "Transitive",
-        "resolved": "4.5.5",
+        "resolved": "6.0.1",
-        "contentHash": "XIWiDvKPXaTveaB7HVganDlOCRoj03l+jrwNvcge/t8vhGYKvqV+dMv6G4SAX2NoNmN0wZfVPTAlFwZcZvVOUw=="
+        "contentHash": "0YhHcaroWpQ9UCot3Pizah7ryAzQhNvobLMSxeDIGmnXfkQn8u5owvpOH0K6EVB+z9L7u6Cc4W17Br/+jyttEQ==",
-      },
+        "dependencies": {
-      "System.Reflection.Emit": {
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0"
-        "type": "Transitive",
+        }
-        "resolved": "4.7.0",
-        "contentHash": "VR4kk8XLKebQ4MZuKuIni/7oh+QGFmZW3qORd1GvBq/8026OpW501SzT/oypwiQl4TvT8ErnReh/NzY9u+C6wQ=="
-      },
-      "System.Reflection.Emit.Lightweight": {
-        "type": "Transitive",
-        "resolved": "4.7.0",
-        "contentHash": "a4OLB4IITxAXJeV74MDx49Oq2+PsF6Sml54XAFv+2RyWwtDBcabzoxiiJRhdhx+gaohLh4hEGCLQyBozXoQPqA=="
       },
       "System.Reflection.Metadata": {
         "type": "Transitive",
-        "resolved": "5.0.0",
+        "resolved": "7.0.0",
-        "contentHash": "5NecZgXktdGg34rh1OenY1rFNDCI8xSjFr+Z4OU4cU06AQHUdRnIIEeWENu3Wl4YowbzkymAIMvi3WyK9U53pQ=="
+        "contentHash": "MclTG61lsD9sYdpNz9xsKBzjsmsfCtcMZYXz/IUr2zlhaTaABonlr1ESeompTgM+Xk+IwtGYU7/voh3YWB/fWw==",
+        "dependencies": {
+          "System.Collections.Immutable": "7.0.0"
+        }
       },
       "System.Runtime.CompilerServices.Unsafe": {
         "type": "Transitive",
         "resolved": "6.0.0",
         "contentHash": "/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg=="
       },
+      "System.Security.Cryptography.Cng": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "jIMXsKn94T9JY7PvPq/tMfqa6GAaHpElRDpmG+SuL+D3+sTw2M8VhnibKnN8Tq+4JqbPJ/f+BwtLeDMEnzAvRg==",
+        "dependencies": {
+          "System.Formats.Asn1": "5.0.0"
+        }
+      },
       "System.Security.Cryptography.Pkcs": {
         "type": "Transitive",
         "resolved": "7.0.0",
@@ -441,6 +538,11 @@
           "System.Formats.Asn1": "7.0.0"
         }
       },
+      "System.Security.Cryptography.ProtectedData": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "cJV7ScGW7EhatRsjehfvvYVBvtiSMKgN8bOVI0bQhnF5bU7vnHVIsH49Kva7i7GWaWYvmEzkYVk1TC+gZYBEog=="
+      },
       "System.Security.Cryptography.Xml": {
         "type": "Transitive",
         "resolved": "7.0.0",
@@ -451,21 +553,13 @@
       },
       "System.Text.Encoding.CodePages": {
         "type": "Transitive",
-        "resolved": "6.0.0",
+        "resolved": "7.0.0",
-        "contentHash": "ZFCILZuOvtKPauZ/j/swhvw68ZRi9ATCfvGbk1QfydmcXBkIWecWKn/250UH7rahZ5OoDBaiAudJtPvLwzw85A==",
+        "contentHash": "LSyCblMpvOe0N3E+8e0skHcrIhgV2huaNcjUUEa8hRtgEAm36aGkRoC8Jxlb6Ra6GSfF29ftduPNywin8XolzQ=="
-        "dependencies": {
-          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
-        }
       },
       "System.Text.Json": {
         "type": "Transitive",
-        "resolved": "5.0.1",
+        "resolved": "5.0.2",
-        "contentHash": "/UM3UK1dXKl8Ybysg/21gM4S8DJgkR+yLU8JwqCVbuNqQNImelntgYFAN5QxR8sJJ1kMx//hOUdf0lltosi8cQ=="
+        "contentHash": "I47dVIGiV6SfAyppphxqupertT/5oZkYLDCX6vC3HpOI4ZLjyoKAreUoem2ie6G0RbRuFrlqz/PcTQjfb2DOfQ=="
-      },
-      "System.Threading.Tasks.Extensions": {
-        "type": "Transitive",
-        "resolved": "4.5.4",
-        "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg=="
       },
       "Torch.SixLabors.ImageSharp": {
         "type": "Transitive",
@@ -479,25 +573,29 @@
       "torch": {
         "type": "Project",
         "dependencies": {
-          "ControlzEx": "[5.0.2, )",
+          "ControlzEx": "[6.0.0, )",
-          "HarmonyX": "[2.10.2-prerelease.1, )",
+          "HarmonyX": "[2.10.2-prerelease.6, )",
           "MahApps.Metro": "[2.4.9, )",
-          "Microsoft.CodeAnalysis.CSharp": "[4.4.0, )",
+          "Microsoft.CodeAnalysis.CSharp": "[4.6.0, )",
-          "Microsoft.CodeAnalysis.Common": "[4.4.0, )",
+          "Microsoft.CodeAnalysis.Common": "[4.6.0, )",
-          "MonoModReorg.RuntimeDetour": "[22.11.21-prerelease.2, )",
+          "MonoMod.RuntimeDetour": "[25.0.0, )",
-          "NLog": "[5.1.0, )",
+          "NLog": "[5.2.2, )",
           "System.ComponentModel.Annotations": "[5.0.0, )",
           "Torch.API": "[1.0.0, )",
           "Torch.SixLabors.ImageSharp": "[1.0.0-beta6, )",
-          "protobuf-net": "[3.1.26, )"
+          "protobuf-net": "[3.2.26, )"
         }
       },
       "torch.api": {
         "type": "Project",
         "dependencies": {
           "JorgeSerrano.Json.JsonSnakeCaseNamingPolicy": "[0.9.0, )",
-          "NLog": "[5.1.0, )",
+          "Microsoft.Extensions.Configuration.Binder": "[7.0.4, )",
-          "SemanticVersioning": "[2.0.2, )"
+          "NLog": "[5.2.2, )",
+          "NuGet.Commands": "[6.6.1, )",
+          "NuGet.DependencyResolver.Core": "[6.6.1, )",
+          "SemanticVersioning": "[2.0.2, )",
+          "System.Linq.Async": "[6.0.1, )"
         }
       }
     },
@@ -510,13 +608,21 @@
       },
       "System.Management": {
         "type": "Direct",
-        "requested": "[7.0.0, )",
+        "requested": "[7.0.2, )",
-        "resolved": "7.0.0",
+        "resolved": "7.0.2",
-        "contentHash": "A4jed4QUviDOm7fJNKAJObEAEkEUXmkGL/w0iyCYTzrl1rezTj8LGFHfsVst4Vb9JwFcTpboiDrvdST48avBpw==",
+        "contentHash": "/qEUN91mP/MUQmJnM5y5BdT7ZoPuVrtxnFlbJ8a3kBJGhe2wCzBfnPFtK2wTtEEcf3DMGR9J00GZZfg6HRI6yA==",
         "dependencies": {
           "System.CodeDom": "7.0.0"
         }
       },
+      "System.Security.Cryptography.Cng": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "jIMXsKn94T9JY7PvPq/tMfqa6GAaHpElRDpmG+SuL+D3+sTw2M8VhnibKnN8Tq+4JqbPJ/f+BwtLeDMEnzAvRg==",
+        "dependencies": {
+          "System.Formats.Asn1": "5.0.0"
+        }
+      },
       "System.Security.Cryptography.Pkcs": {
         "type": "Transitive",
         "resolved": "7.0.0",
@@ -525,13 +631,15 @@
           "System.Formats.Asn1": "7.0.0"
         }
       },
+      "System.Security.Cryptography.ProtectedData": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "cJV7ScGW7EhatRsjehfvvYVBvtiSMKgN8bOVI0bQhnF5bU7vnHVIsH49Kva7i7GWaWYvmEzkYVk1TC+gZYBEog=="
+      },
       "System.Text.Encoding.CodePages": {
         "type": "Transitive",
-        "resolved": "6.0.0",
+        "resolved": "7.0.0",
-        "contentHash": "ZFCILZuOvtKPauZ/j/swhvw68ZRi9ATCfvGbk1QfydmcXBkIWecWKn/250UH7rahZ5OoDBaiAudJtPvLwzw85A==",
+        "contentHash": "LSyCblMpvOe0N3E+8e0skHcrIhgV2huaNcjUUEa8hRtgEAm36aGkRoC8Jxlb6Ra6GSfF29ftduPNywin8XolzQ=="
-        "dependencies": {
-          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
-        }
       }
     }
   }

Torch.Tests/Torch.Tests.csproj

@@ -17,8 +17,8 @@
   </PropertyGroup>
 <!--   <Import Project="$(SolutionDir)\TransformOnBuild.targets" /> -->
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.3" />
-    <PackageReference Include="NLog" Version="5.1.0" />
+    <PackageReference Include="NLog" Version="5.2.2" />
     <PackageReference Include="xunit" Version="2.4.2" />
   </ItemGroup>
   <ItemGroup>

Torch/Managers/EntityManager.cs

@@ -27,6 +27,7 @@ using VRage.Game.ModAPI;
 using VRage.Groups;
 using VRage.ModAPI;
 using VRage.ObjectBuilders;
+using VRage.ObjectBuilders.Private;
 using VRage.Sync;
 using VRageMath;
 
@@ -45,14 +46,14 @@ namespace Torch.Managers
         {
             var ob = grid.GetObjectBuilder(true);
             using (var f = File.Open(path, FileMode.CreateNew))
-                MyObjectBuilderSerializer.SerializeXML(f, ob);
+                MyObjectBuilderSerializerKeen.SerializeXML(f, ob);
         }
 
         public void ImportGrid(string path, Vector3D position)
         {
             MyObjectBuilder_EntityBase gridOb;
             using (var f = File.OpenRead(path))
-                MyObjectBuilderSerializer.DeserializeXML(f, out gridOb);
+                MyObjectBuilderSerializerKeen.DeserializeXML(f, out gridOb);
 
             var grid = MyEntities.CreateFromObjectBuilderParallel(gridOb);
             grid.PositionComp.SetPosition(position);

Torch/Managers/FilesystemManager.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using System.Text;
 using System.Threading.Tasks;
 using NLog;
@@ -9,7 +10,7 @@ using Torch.API;
 
 namespace Torch.Managers
 {
-    public class FilesystemManager : Manager
+    public partial class FilesystemManager : Manager
     {
         private static readonly Logger _log = LogManager.GetCurrentClassLogger();
         /// <summary>
@@ -51,19 +52,31 @@ namespace Torch.Managers
             }
         }
 
-        /// <summary>
-        /// Move the given file (if it exists) to a temporary directory that will be cleared the next time the application starts.
-        /// </summary>
         public void SoftDelete(string path, string file)
         {
-            string source = Path.Combine(path, file);
+            var source = Path.Combine(path, file);
             if (!File.Exists(source))
                 return;
-            var rand = Path.GetRandomFileName();
+
-            var dest = Path.Combine(TempDirectory, rand);
+            try
-            File.Move(source, rand);
+            {
-            string rsource = Path.Combine(path, rand);
+                File.Delete(source);
-            File.Move(rsource, dest);
+            }
+            catch (Exception e) when (e is IOException or UnauthorizedAccessException)
+            {
+                var tempFilePath = Path.Combine(path, file + ".old");
+                if (File.Exists(tempFilePath))
+                    File.Delete(tempFilePath);
+
+                try
+                {
+                    File.Move(source, tempFilePath);
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    // ignore
+                }
+            }
         }
     }
 }

Torch/Managers/PatchManager/DecoratedMethod.cs

@@ -1,40 +1,34 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.ComponentModel.Design;
-using System.Diagnostics;
-using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
-using System.Runtime.CompilerServices;
+using HarmonyLib;
-using System.Runtime.InteropServices;
-using MonoMod.Cil;
-using MonoMod.RuntimeDetour;
 using MonoMod.Utils;
-using MonoMod.Utils.Cil;
 using NLog;
 using Torch.Managers.PatchManager.MSIL;
 using Torch.Managers.PatchManager.Transpile;
-using Torch.Utils;
 
 namespace Torch.Managers.PatchManager
 {
     internal class DecoratedMethod : MethodRewritePattern
     {
-        [ReflectedMethodInfo(typeof(MethodBase), nameof(MethodBase.GetMethodFromHandle), Parameters = new[] {typeof(RuntimeMethodHandle)})]
+        private static readonly ConcurrentDictionary<MethodBase, DecoratedMethod> Methods = new();
-        private static MethodInfo _getMethodFromHandle = null!;
-        
-        [ReflectedMethodInfo(typeof(MethodBase), nameof(MethodBase.GetMethodFromHandle), Parameters = new[] {typeof(RuntimeMethodHandle), typeof(RuntimeTypeHandle)})]
-        private static MethodInfo _getMethodFromHandleGeneric = null!;
 
         private static readonly Logger _log = LogManager.GetCurrentClassLogger();
         private readonly MethodBase _method;
+        private readonly Harmony _harmony;
 
-        private ILHook _hook;
+        private readonly PatchProcessor _processor;
+        private bool _hasRan;
 
-        internal DecoratedMethod(MethodBase method) : base(null)
+        internal DecoratedMethod(MethodBase method, Harmony harmony) : base(null)
         {
             _method = method;
+            _harmony = harmony;
+            _processor = harmony.CreateProcessor(method);
+            Methods[method] = this;
         }
 
         internal bool HasChanged()
@@ -56,29 +50,25 @@ namespace Torch.Managers.PatchManager
                 _log.Log(PrintMode != 0 ? LogLevel.Info : LogLevel.Debug,
                     $"Begin patching {_method.DeclaringType?.FullName}#{_method.Name}({string.Join(", ", _method.GetParameters().Select(x => x.ParameterType.Name))})");
 
-                _hook ??= new ILHook(_method, Manipulator, false);
+                foreach (var prefix in Prefixes)
-                try
                 {
-                    _hook.Apply();
+                    _processor.AddPrefix(prefix);
-                }
-                catch (InvalidProgramException e)
-                {
-                    _hook.Undo();
-                    PrintMode = PrintModeEnum.Emitted | PrintModeEnum.Original;
-                    try
-                    {
-                        _hook.Apply();
-                    }
-                    catch
-                    {
-                        // Ignore, we are already know there is an error in IL
                 }
                 
-                    throw;
+                foreach (var suffix in Suffixes)
+                {
+                    _processor.AddPostfix(suffix);
                 }
 
+                if (Transpilers.Any() || PostTranspilers.Any())
+                    _processor.AddTranspiler(SymbolExtensions.GetMethodInfo(() => TranspilerProxy(null, null, null)));
+
+                _processor.Patch();
+
                 _log.Log(PrintMode != 0 ? LogLevel.Info : LogLevel.Debug,
                     $"Done patching {_method.GetID()})");
+                
+                _hasRan = true;
             }
             catch (Exception exception)
             {
@@ -87,332 +77,40 @@ namespace Torch.Managers.PatchManager
             }
         }
 
+        private static IEnumerable<CodeInstruction> TranspilerProxy(IEnumerable<CodeInstruction> instructions,
+                                                                    MethodBase __originalMethod,
+                                                                    ILGenerator generator)
+        {
+            if (!Methods.TryGetValue(__originalMethod, out var decoratedMethod))
+                throw new Exception($"Unknown method {__originalMethod.GetID()}");
+
+            var loggingGenerator = new LoggingIlGenerator(generator, decoratedMethod.PrintMode != 0 ? LogLevel.Info : LogLevel.Debug);
+
+            MsilLocal LocalFactory(Type type) => new(loggingGenerator.DeclareLocal(type));
+
+            foreach (var transpiler in decoratedMethod.Transpilers.Concat(decoratedMethod.PostTranspilers))
+            {
+                var ins = (IEnumerable<MsilInstruction>) transpiler.Invoke(null, transpiler.GetParameters().Select<ParameterInfo, object>(b => b switch
+                {
+                    _ when b.ParameterType.IsAssignableTo(typeof(MethodBase)) => __originalMethod,
+                    _ when b.ParameterType.IsAssignableTo(typeof(IEnumerable<MsilInstruction>)) => instructions.Select(c => new MsilInstruction(c)),
+                    _ when b.ParameterType.IsAssignableTo(typeof(Func<Type, MsilLocal>)) => new Func<Type, MsilLocal>(LocalFactory),
+                    _ => null
+                }).ToArray());
+
+                instructions = ins!.Select(b => b.ToCodeIns(loggingGenerator)).ToList();
+            }
+
+            return instructions;
+        }
+
         internal void Revert()
         {
-            if (_hook == null)
+            if (!_hasRan)
                 return;
+            
             _log.Debug($"Revert {_method.GetID()}");
-            _hook.Dispose();
+            _processor.Unpatch(HarmonyPatchType.All, _harmony.Id);
-            _hook = null;
-        }
-
-        #region Create
-
-        public const string INSTANCE_PARAMETER = "__instance";
-        public const string RESULT_PARAMETER = "__result";
-        public const string PREFIX_SKIPPED_PARAMETER = "__prefixSkipped";
-        public const string ORIGINAL_PARAMETER = "__original";
-        public const string LOCAL_PARAMETER = "__local";
-
-        private void SavePatchedMethod(string target)
-        {
-            throw new NotSupportedException();
-            // var asmBuilder =
-            //     AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("SomeName"), AssemblyBuilderAccess.RunAndSave, Path.GetDirectoryName(target));
-            // var moduleBuilder = asmBuilder.DefineDynamicModule(Path.GetFileNameWithoutExtension(target), Path.GetFileName(target));
-            // var typeBuilder = moduleBuilder.DefineType("Test", TypeAttributes.Public);
-            //
-            //
-            // var methodName = _method.Name + $"_{_patchSalt}";
-            // var returnType = _method is MethodInfo meth ? meth.ReturnType : typeof(void);
-            // var parameters = _method.GetParameters();
-            // var parameterTypes = (_method.IsStatic ? Enumerable.Empty<Type>() : new[] {_method.DeclaringType})
-            //     .Concat(parameters.Select(x => x.ParameterType)).ToArray();
-            //
-            // var patchMethod = typeBuilder.DefineMethod(methodName, MethodAttributes.Public | MethodAttributes.Static, CallingConventions.Standard,
-            //     returnType, parameterTypes);
-            // if (!_method.IsStatic)
-            //     patchMethod.DefineParameter(0, ParameterAttributes.None, INSTANCE_PARAMETER);
-            // for (var i = 0; i < parameters.Length; i++)
-            //     patchMethod.DefineParameter((patchMethod.IsStatic ? 0 : 1) + i, parameters[i].Attributes, parameters[i].Name);
-            //
-            // var generator = new LoggingIlGenerator(patchMethod.GetILGenerator(), LogLevel.Trace);
-            // List<MsilInstruction> il = EmitPatched((type, pinned) => new MsilLocal(generator.DeclareLocal(type, pinned))).ToList();
-            //
-            // MethodTranspiler.EmitMethod(il, generator);
-            //
-            // Type res = typeBuilder.CreateType();
-            // asmBuilder.Save(Path.GetFileName(target));
-            // foreach (var method in res.GetMethods(BindingFlags.Public | BindingFlags.Static))
-            //     _log.Info($"Information " + method);
-        }
-
-        public void Manipulator(ILContext context)
-        {
-            context.IL.Clear();
-            var generator = new LoggingIlGenerator(new CecilILGenerator(context.IL),
-                PrintMode.HasFlag(PrintModeEnum.EmittedReflection) ? LogLevel.Info : LogLevel.Trace);
-            List<MsilInstruction> il = EmitPatched((type, pinned) => new MsilLocal(generator.DeclareLocal(type, pinned))).ToList();
-
-            var dumpTarget = DumpTarget != null ? File.CreateText(DumpTarget) : null;
-            try
-            {
-                const string gap = "\n\n\n\n\n";
-
-                void LogTarget(PrintModeEnum mode, bool err, string msg)
-                {
-                    if (DumpMode.HasFlag(mode))
-                        dumpTarget?.WriteLine((err ? "ERROR " : "") + msg);
-                    if (!PrintMode.HasFlag(mode)) return;
-                    if (err)
-                        _log.Error(msg);
-                    else
-                        _log.Info(msg);
-                }
-
-#pragma warning disable CS0612
-                if (PrintMsil || DumpTarget != null)
-#pragma warning restore CS0612
-                {
-                    lock (_log)
-                    {
-                        var ctx = new MethodContext(_method);
-                        ctx.Read();
-                        LogTarget(PrintModeEnum.Original, false, "========== Original method ==========");
-                        MethodTranspiler.IntegrityAnalysis((a, b) => LogTarget(PrintModeEnum.Original, a, b), ctx.Instructions, true);
-                        LogTarget(PrintModeEnum.Original, false, gap);
-
-                        LogTarget(PrintModeEnum.Emitted, false, "========== Desired method ==========");
-                        MethodTranspiler.IntegrityAnalysis((a, b) => LogTarget(PrintModeEnum.Emitted, a, b), il);
-                        LogTarget(PrintModeEnum.Emitted, false, gap);
-                        // If the method is invalid the program is likely to hard crash in EmitMethod or Compile, so flush the log
-                        LogManager.Flush();
-                    }
-                }
-
-                MethodTranspiler.EmitMethod(il, generator);
-
-#pragma warning disable CS0612
-                if (PrintMsil || DumpTarget != null)
-#pragma warning restore CS0612
-                {
-                    lock (_log)
-                    {
-                        var instructions = context.Body.Instructions
-                            .Select(b => b.ToMsilInstruction()).ToList();
-                        LogTarget(PrintModeEnum.Patched, false, "========== Patched method ==========");
-                        MethodTranspiler.IntegrityAnalysis((a, b) => LogTarget(PrintModeEnum.Patched, a, b), instructions, true);
-                        LogTarget(PrintModeEnum.Patched, false, gap);
         }
     }
 }
-            finally
-            {
-                dumpTarget?.Close();
-            }
-        }
-
-        #endregion
-
-        #region Emit
-
-        private IEnumerable<MsilInstruction> EmitPatched(Func<Type, bool, MsilLocal> declareLocal)
-        {
-            var methodBody = _method.GetMethodBody();
-            Debug.Assert(methodBody != null, "Method body is null");
-            foreach (var localVar in methodBody.LocalVariables)
-            {
-                Debug.Assert(localVar.LocalType != null);
-                declareLocal(localVar.LocalType, localVar.IsPinned);
-            }
-
-            var instructions = new List<MsilInstruction>();
-            var specialVariables = new Dictionary<string, MsilLocal>();
-
-            var labelAfterOriginalContent = new MsilLabel();
-            var labelSkipMethodContent = new MsilLabel();
-
-
-            Type returnType = _method is MethodInfo meth ? meth.ReturnType : typeof(void);
-            MsilLocal resultVariable = null;
-            if (returnType != typeof(void))
-            {
-                if (Prefixes.Concat(Suffixes).SelectMany(x => x.GetParameters()).Any(x => x.Name == RESULT_PARAMETER)
-                    || Prefixes.Any(x => x.ReturnType == typeof(bool)))
-                    resultVariable = declareLocal(returnType, false);
-            }
-
-            if (resultVariable != null)
-                instructions.AddRange(resultVariable.SetToDefault());
-            MsilLocal prefixSkippedVariable = null;
-            if (Prefixes.Count > 0 && Suffixes.Any(x => x.GetParameters()
-                    .Any(y => y.Name.Equals(PREFIX_SKIPPED_PARAMETER))))
-            {
-                prefixSkippedVariable = declareLocal(typeof(bool), false);
-                specialVariables.Add(PREFIX_SKIPPED_PARAMETER, prefixSkippedVariable);
-            }
-
-            if (resultVariable != null)
-                specialVariables.Add(RESULT_PARAMETER, resultVariable);
-
-            // Create special variables
-            foreach (var m in Prefixes.Concat(Suffixes))
-            foreach (var param in m.GetParameters())
-                if (param.Name.StartsWith(LOCAL_PARAMETER))
-                {
-                    var requiredType = param.ParameterType.IsByRef ? param.ParameterType.GetElementType() : param.ParameterType;
-                    if (specialVariables.TryGetValue(param.Name, out var existingParam))
-                    {
-                        if (existingParam.Type != requiredType)
-                            throw new ArgumentException(
-                                $"Trying to use injected local {param.Name} for {m.DeclaringType?.FullName}#{m.ToString()} with type {requiredType} but a local with the same name already exists with type {existingParam.Type}",
-                                param.Name);
-                    }
-                    else
-                        specialVariables.Add(param.Name, declareLocal(requiredType, false));
-                }
-
-            foreach (MethodInfo prefix in Prefixes)
-            {
-                instructions.AddRange(EmitMonkeyCall(prefix, specialVariables));
-                if (prefix.ReturnType == typeof(bool))
-                    instructions.Add(new MsilInstruction(OpCodes.Brfalse).InlineTarget(labelSkipMethodContent));
-                else if (prefix.ReturnType != typeof(void))
-                    throw new PatchException(
-                        $"Prefixes must return void or bool.  {prefix.DeclaringType?.FullName}.{prefix.Name} returns {prefix.ReturnType}", prefix);
-            }
-
-            instructions.AddRange(MethodTranspiler.Transpile(_method, (x) => declareLocal(x, false), Transpilers, labelAfterOriginalContent));
-
-            instructions.Add(new MsilInstruction(OpCodes.Nop).LabelWith(labelAfterOriginalContent));
-            if (resultVariable != null)
-                instructions.Add(new MsilInstruction(OpCodes.Stloc).InlineValue(resultVariable));
-            var notSkip = new MsilLabel();
-            instructions.Add(new MsilInstruction(OpCodes.Br).InlineTarget(notSkip));
-            instructions.Add(new MsilInstruction(OpCodes.Nop).LabelWith(labelSkipMethodContent));
-            if (prefixSkippedVariable != null)
-            {
-                instructions.Add(new MsilInstruction(OpCodes.Ldc_I4_1));
-                instructions.Add(new MsilInstruction(OpCodes.Stloc).InlineValue(prefixSkippedVariable));
-            }
-
-            instructions.Add(new MsilInstruction(OpCodes.Nop).LabelWith(notSkip));
-
-            foreach (MethodInfo suffix in Suffixes)
-            {
-                instructions.AddRange(EmitMonkeyCall(suffix, specialVariables));
-                if (suffix.ReturnType != typeof(void))
-                    throw new PatchException($"Suffixes must return void.  {suffix.DeclaringType?.FullName}.{suffix.Name} returns {suffix.ReturnType}", suffix);
-            }
-
-            if (resultVariable != null)
-                instructions.Add(new MsilInstruction(OpCodes.Ldloc).InlineValue(resultVariable));
-            instructions.Add(new MsilInstruction(OpCodes.Ret));
-
-            var result = MethodTranspiler.Transpile(_method, instructions, (x) => declareLocal(x, false), PostTranspilers, null).ToList();
-            if (result.Last().OpCode != OpCodes.Ret)
-                result.Add(new MsilInstruction(OpCodes.Ret));
-            return result;
-        }
-
-        private IEnumerable<MsilInstruction> EmitMonkeyCall(MethodInfo patch,
-            IReadOnlyDictionary<string, MsilLocal> specialVariables)
-        {
-            foreach (var param in patch.GetParameters())
-            {
-                switch (param.Name)
-                {
-                    case INSTANCE_PARAMETER:
-                    {
-                        if (_method.IsStatic)
-                            throw new PatchException("Can't use an instance parameter for a static method", _method);
-                        yield return new MsilInstruction(OpCodes.Ldarg_0);
-                        break;
-                    }
-                    case ORIGINAL_PARAMETER:
-                    {
-                        if (!typeof(MethodBase).IsAssignableFrom(param.ParameterType))
-                            throw new PatchException($"Original parameter should be assignable to {nameof(MethodBase)}",
-                                _method);
-                        yield return new MsilInstruction(OpCodes.Ldtoken).InlineValue(_method);
-                        if (_method.DeclaringType!.ContainsGenericParameters)
-                        {
-                            yield return new MsilInstruction(OpCodes.Ldtoken).InlineValue(_method.DeclaringType);
-                            yield return new MsilInstruction(OpCodes.Call).InlineValue(_getMethodFromHandleGeneric);
-                        }
-                        else
-                            yield return new MsilInstruction(OpCodes.Call).InlineValue(_getMethodFromHandle);
-
-                        if (param.ParameterType != typeof(MethodBase))
-                            yield return new MsilInstruction(OpCodes.Castclass).InlineValue(param.ParameterType);
-                        break;
-                    }
-                    case PREFIX_SKIPPED_PARAMETER:
-                    {
-                        if (param.ParameterType != typeof(bool))
-                            throw new PatchException($"Prefix skipped parameter {param.ParameterType} must be of type bool", _method);
-                        if (param.ParameterType.IsByRef || param.IsOut)
-                            throw new PatchException($"Prefix skipped parameter {param.ParameterType} can't be a reference type", _method);
-                        if (specialVariables.TryGetValue(PREFIX_SKIPPED_PARAMETER, out MsilLocal prefixSkip))
-                            yield return new MsilInstruction(OpCodes.Ldloc).InlineValue(prefixSkip);
-                        else
-                            yield return new MsilInstruction(OpCodes.Ldc_I4_0);
-                        break;
-                    }
-                    case RESULT_PARAMETER:
-                    {
-                        var retType = param.ParameterType.IsByRef
-                            ? param.ParameterType.GetElementType()
-                            : param.ParameterType;
-                        if (retType == null || !retType.IsAssignableFrom(specialVariables[RESULT_PARAMETER].Type))
-                            throw new PatchException(
-                                $"Return type {specialVariables[RESULT_PARAMETER].Type} can't be assigned to result parameter type {retType}", _method);
-                        yield return new MsilInstruction(param.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc)
-                            .InlineValue(specialVariables[RESULT_PARAMETER]);
-                        break;
-                    }
-                    default:
-                    {
-                        if (specialVariables.TryGetValue(param.Name, out var specialVar))
-                        {
-                            yield return new MsilInstruction(param.ParameterType.IsByRef ? OpCodes.Ldloca : OpCodes.Ldloc)
-                                .InlineValue(specialVar);
-                            break;
-                        }
-
-                        if (param.Name.StartsWith("__field_"))
-                        {
-                            var fieldName = param.Name.Substring(8);
-                            var fieldDef = _method.DeclaringType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static).FirstOrDefault(x => x.Name == fieldName);
-                            if (fieldDef == null) throw new PatchException($"Could not find field {fieldName}", _method);
-                            if (fieldDef.IsStatic)
-                                yield return new MsilInstruction(param.ParameterType.IsByRef ? OpCodes.Ldsflda : OpCodes.Ldsfld)
-                                    .InlineValue(fieldDef);
-                            else
-                            {
-                                yield return new MsilInstruction(OpCodes.Ldarg_0);
-                                yield return new MsilInstruction(param.ParameterType.IsByRef ? OpCodes.Ldflda : OpCodes.Ldfld)
-                                    .InlineValue(fieldDef);
-                            }
-                            break;
-                        }
-
-                        ParameterInfo declParam = _method.GetParameters().FirstOrDefault(x => x.Name == param.Name);
-
-                        if (declParam == null)
-                            throw new PatchException($"Parameter name {param.Name} not found", _method);
-                        int paramIdx = (_method.IsStatic ? 0 : 1) + declParam.Position;
-
-                        bool patchByRef = param.IsOut || param.ParameterType.IsByRef;
-                        bool declByRef = declParam.IsOut || declParam.ParameterType.IsByRef;
-                        if (patchByRef == declByRef)
-                            yield return new MsilInstruction(OpCodes.Ldarg).InlineValue(new MsilArgument(paramIdx));
-                        else if (patchByRef)
-                            yield return new MsilInstruction(OpCodes.Ldarga).InlineValue(new MsilArgument(paramIdx));
-                        else
-                        {
-                            yield return new MsilInstruction(OpCodes.Ldarg).InlineValue(new MsilArgument(paramIdx));
-                            yield return EmitExtensions.EmitDereference(declParam.ParameterType);
-                        }
-
-                        break;
-                    }
-                }
-            }
-
-            yield return new MsilInstruction(OpCodes.Call).InlineValue(patch);
-        }
-
-        #endregion
-    }
-}

Torch/Managers/PatchManager/MSIL/MsilInstruction.cs

@@ -7,6 +7,7 @@ using System.Reflection;
 using System.Reflection.Emit;
 using System.Text;
 using System.Windows.Documents;
+using HarmonyLib;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using MonoMod.Utils;
@@ -89,6 +90,94 @@ namespace Torch.Managers.PatchManager.MSIL
             }
         }
         
+        public MsilInstruction(CodeInstruction instruction) : this(instruction.opcode)
+        {
+            switch (instruction.operand)
+            {
+                case LocalBuilder builder when Operand is MsilOperandInline.MsilOperandLocal operandLocal:
+                    operandLocal.Value = new(builder);
+                    break;
+                case MethodBase methodBase when Operand is MsilOperandInline.MsilOperandReflected<MethodBase> operandMethod:
+                    operandMethod.Value = methodBase;
+                    break;
+                case Type type when Operand is MsilOperandInline.MsilOperandReflected<Type> operandType:
+                    operandType.Value = type;
+                    break;
+                case MemberInfo info when Operand is MsilOperandInline.MsilOperandReflected<MemberInfo> operandMember:
+                    operandMember.Value = info;
+                    break;
+                case IEnumerable<Label> labels when Operand is MsilOperandSwitch operandSwitch:
+                    operandSwitch.Labels = labels.Select(b => new MsilLabel(b)).ToArray();
+                    break;
+                case float single when Operand is MsilOperandInline.MsilOperandSingle operandSingle:
+                    operandSingle.Value = single;
+                    break;
+                case FieldInfo fieldInfo when Operand is MsilOperandInline.MsilOperandReflected<FieldInfo> operandField:
+                    operandField.Value = fieldInfo;
+                    break;
+                case string str when Operand is MsilOperandInline.MsilOperandString operandString:
+                    operandString.Value = str;
+                    break;
+                case SignatureHelper signatureHelper when Operand is MsilOperandInline.MsilOperandSignature operandSignature:
+                    operandSignature.Value = signatureHelper;
+                    break;
+                case int int32 when Operand is MsilOperandInline.MsilOperandInt32 operandInt32:
+                    operandInt32.Value = int32;
+                    break;
+                case long int64 when Operand is MsilOperandInline.MsilOperandInt64 operandInt64:
+                    operandInt64.Value = int64;
+                    break;
+                case Label label when Operand is MsilOperandBrTarget operandBrTarget:
+                    operandBrTarget.Target = new(label);
+                    break;
+                case double @double when Operand is MsilOperandInline.MsilOperandDouble operandDouble:
+                    operandDouble.Value = @double;
+                    break;
+                case byte @byte when Operand is MsilOperandInline.MsilOperandArgument operandArgument:
+                    operandArgument.Value = new(@byte);
+                    break;
+                case byte @byte when Operand is MsilOperandInline.MsilOperandLocal operandArgument:
+                    operandArgument.Value = new(@byte);
+                    break;
+            }
+
+            Labels = instruction.labels.Select(b => new MsilLabel(b)).ToHashSet();
+            TryCatchOperations =
+                instruction.blocks.Select(
+                    b => new MsilTryCatchOperation((MsilTryCatchOperationType)b.blockType, b.catchType == typeof(object) ? null : b.catchType)).ToList();
+        }
+
+        internal CodeInstruction ToCodeIns(LoggingIlGenerator generator)
+        {
+            var ins = new CodeInstruction(OpCode, Operand switch
+            {
+                MsilOperandBrTarget msilOperandBrTarget => msilOperandBrTarget.Target.LabelFor(generator),
+                MsilOperandInline.MsilOperandReflected<MethodBase> msilOperandReflected => msilOperandReflected.Value,
+                MsilOperandInline.MsilOperandReflected<MemberInfo> msilOperandReflected => msilOperandReflected.Value,
+                MsilOperandInline.MsilOperandReflected<FieldInfo> msilOperandReflected => msilOperandReflected.Value,
+                MsilOperandInline.MsilOperandReflected<Type> msilOperandReflected => msilOperandReflected.Value,
+                MsilOperandInline.MsilOperandDouble msilOperandDouble => msilOperandDouble.Value,
+                MsilOperandInline.MsilOperandInt32 msilOperandInt32 => msilOperandInt32.Value,
+                MsilOperandInline.MsilOperandInt64 msilOperandInt64 => msilOperandInt64.Value,
+                MsilOperandInline.MsilOperandLocal msilOperandLocal when OpCode.OperandType == OperandType.InlineVar => msilOperandLocal.Value.Local,
+                MsilOperandInline.MsilOperandLocal msilOperandLocal when OpCode.OperandType == OperandType.ShortInlineVar => (byte)msilOperandLocal.Value.Index,
+                MsilOperandInline.MsilOperandArgument msilOperandArgument when OpCode.OperandType == OperandType.InlineVar => msilOperandArgument.Value,
+                MsilOperandInline.MsilOperandArgument msilOperandArgument when OpCode.OperandType == OperandType.ShortInlineVar => (byte)msilOperandArgument.Value.Position,
+                MsilOperandInline.MsilOperandSignature msilOperandSignature => msilOperandSignature.Value,
+                MsilOperandInline.MsilOperandSingle msilOperandSingle => msilOperandSingle.Value,
+                MsilOperandInline.MsilOperandString msilOperandString => msilOperandString.Value,
+                MsilOperandSwitch msilOperandSwitch => msilOperandSwitch.Labels.Select(b => b.LabelFor(generator)).ToArray(),
+                _ => null
+            })
+            {
+                labels = Labels.Select(b => b.LabelFor(generator)).ToList(),
+                blocks = TryCatchOperations.Select(b => new ExceptionBlock((ExceptionBlockType)b.Type, b.CatchType))
+                                           .ToList()
+            };
+
+            return ins;
+        }
+
         /// <summary>
         ///     Opcode of this instruction
         /// </summary>

Torch/Managers/PatchManager/MSIL/MsilLabel.cs

@@ -13,14 +13,14 @@ namespace Torch.Managers.PatchManager.MSIL
         private readonly List<KeyValuePair<WeakReference<LoggingIlGenerator>, Label>> _labelInstances =
             new List<KeyValuePair<WeakReference<LoggingIlGenerator>, Label>>();
 
-        private readonly Label? _overrideLabel;
+        internal readonly Label? OverrideLabel;
 
         /// <summary>
         ///     Creates an empty label the allocates a new <see cref="Label" /> when requested.
         /// </summary>
         public MsilLabel()
         {
-            _overrideLabel = null;
+            OverrideLabel = null;
         }
 
         /// <summary>
@@ -28,7 +28,7 @@ namespace Torch.Managers.PatchManager.MSIL
         /// </summary>
         public MsilLabel(Label overrideLabel)
         {
-            _overrideLabel = overrideLabel;
+            OverrideLabel = overrideLabel;
         }
 
         /// <summary>
@@ -46,8 +46,8 @@ namespace Torch.Managers.PatchManager.MSIL
 
         internal Label LabelFor(LoggingIlGenerator gen)
         {
-            if (_overrideLabel.HasValue)
+            if (OverrideLabel.HasValue)
-                return _overrideLabel.Value;
+                return OverrideLabel.Value;
             foreach (KeyValuePair<WeakReference<LoggingIlGenerator>, Label> kv in _labelInstances)
                 if (kv.Key.TryGetTarget(out LoggingIlGenerator gen2) && gen2 == gen)
                     return kv.Value;

Torch/Managers/PatchManager/MSIL/MsilLocal.cs

@@ -14,6 +14,8 @@ namespace Torch.Managers.PatchManager.MSIL
     /// </summary>
     public class MsilLocal
     {
+        internal LocalBuilder Local { get; }
+
         /// <summary>
         /// The index of this local.
         /// </summary>
@@ -31,6 +33,7 @@ namespace Torch.Managers.PatchManager.MSIL
 
         internal MsilLocal(LocalBuilder local)
         {
+            Local = local;
             Index = local.LocalIndex;
             Type = local.LocalType;
             Name = null;

Torch/Managers/PatchManager/PatchManager.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Threading;
+using HarmonyLib;
 using NLog;
 using Torch.API;
 using Torch.Managers.PatchManager.Transpile;
@@ -65,6 +66,7 @@ namespace Torch.Managers.PatchManager
         private static readonly Dictionary<Assembly, List<PatchContext>> _contexts = new Dictionary<Assembly, List<PatchContext>>();
         // ReSharper disable once CollectionNeverQueried.Local because we may want this in the future.
         private static readonly List<PatchContext> _coreContexts = new List<PatchContext>();
+        private static readonly Harmony HarmonyInstance = new("PatchManager");
 
         /// <inheritdoc cref="GetPattern"/>
         internal static MethodRewritePattern GetPatternInternal(MethodBase method)
@@ -73,7 +75,7 @@ namespace Torch.Managers.PatchManager
             {
                 if (_rewritePatterns.TryGetValue(method, out DecoratedMethod pattern))
                     return pattern;
-                var res = new DecoratedMethod(method);
+                var res = new DecoratedMethod(method, HarmonyInstance);
                 _rewritePatterns.Add(method, res);
                 return res;
             }

Torch/Managers/PatchManager/Transpile/LoggingILGenerator.cs

@@ -25,7 +25,7 @@ namespace Torch.Managers.PatchManager.Transpile
         /// <summary>
         /// Backing generator
         /// </summary>
-        public ILGeneratorShim Backing { get; }
+        public ILGenerator Backing { get; }
         
         private readonly LogLevel _level;
 
@@ -33,7 +33,7 @@ namespace Torch.Managers.PatchManager.Transpile
         /// Creates a new logging IL generator backed by the given generator.
         /// </summary>
         /// <param name="backing">Backing generator</param>
-        public LoggingIlGenerator(ILGeneratorShim backing, LogLevel level)
+        public LoggingIlGenerator(ILGenerator backing, LogLevel level)
         {
             Backing = backing;
             _level = level;

Torch/Managers/ScriptCompilationManager.cs

@@ -82,7 +82,7 @@ public class ScriptCompilationManager : Manager
         TerminationReasonSetter(block, MyProgrammableBlock.ScriptTerminationReason.None);
 
         var component = ScriptComponentGetter(block);
-        component.NextUpdate = UpdateType.None;
+        component.UpdateFrequency = UpdateFrequency.None;
         component.NeedsUpdate = MyEntityUpdateEnum.NONE;
 
         try
@@ -214,7 +214,8 @@ public class ScriptCompilationManager : Manager
         return null;
     }
 
-    private readonly CSharpCompilationOptions _compilationOptions = new(OutputKind.DynamicallyLinkedLibrary);
+    private readonly CSharpCompilationOptions _compilationOptions = new(OutputKind.DynamicallyLinkedLibrary,
+        optimizationLevel: OptimizationLevel.Release, platform: Platform.X64);
     private readonly CSharpParseOptions _parseOptions = new(LanguageVersion.CSharp11, DocumentationMode.None);
     
     private CSharpCompilation CreateCompilation(string assemblyFileName, IEnumerable<Script> scripts)

Torch/Managers/UpdateManager.cs

@@ -109,8 +109,15 @@ namespace Torch.Managers
                 else
                 {
                     _fsManager.SoftDelete(extractPath, file.FullName);
+                    try
+                    {
                         file.ExtractToFile(targetFile, true);
                     }
+                    catch (Exception e)
+                    {
+                        _log.Warn(e, "unable to extract {0}", targetFile);
+                    }
+                }
             }
 
             //zip.ExtractToDirectory(extractPath); //throws exceptions sometimes?

Torch/Packages/PackageManager.cs

@@ -0,0 +1,162 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using NLog;
+using Torch.API;
+using Torch.API.Managers;
+using Torch.API.WebAPI.Plugins;
+using Torch.Managers;
+using Torch.Utils;
+
+namespace Torch.Packages;
+
+public class PackageManager : Manager, IPackageManager
+{
+    private readonly PluginManager _pluginManager;
+    private static readonly ILogger Log = LogManager.GetCurrentClassLogger();
+
+    private IPackageResolver? _packageResolver;
+
+    public PackageManager(ITorchBase torchInstance, PluginManager pluginManager) : base(torchInstance)
+    {
+        _pluginManager = pluginManager;
+    }
+
+    private AssemblyLoadContext? _loadContext;
+
+    private ImmutableHashSet<Package> _packages = ImmutableHashSet<Package>.Empty;
+    private ImmutableDictionary<Package,Assembly[]> _packageAssemblies = ImmutableDictionary<Package, Assembly[]>.Empty;
+    private DirectoryInfo? _packagesDirectory;
+    public IReadOnlySet<Package> Packages => _packages;
+    
+    public bool TryGetPackageAssemblies(Package package, out Assembly[]? assemblies)
+    {
+        if (!Packages.Contains(package))
+            throw new InvalidOperationException($"Package {package.Name} does not exist");
+        
+        return _packageAssemblies.TryGetValue(package, out assemblies);
+    }
+
+    internal async void LoadAsync(SemaphoreSlim semaphore)
+    {
+        _packagesDirectory = Directory.CreateDirectory(Path.Combine(Torch.InstancePath, "Packages"));
+        _packageResolver = new PackageResolver(new[]
+        { // TODO make this configurable
+            new PackageSource("nuget", "https://api.nuget.org/v3/index.json", new[] { "*" }, PackageSourceType.NuGet)
+        }, _packagesDirectory);
+        
+        try
+        {
+            var packages =
+                Torch.Config.Packages.ToImmutableDictionary(b => b[..b.IndexOf(':')], b => b[(b.IndexOf(':') + 1)..]);
+            await ResolvePackagesAsync(packages);
+
+            var resolvedPackages = await _packages.ToAsyncEnumerable()
+                                                  .SelectAwait(async b =>
+                                                  {
+                                                      var reader = await _packageResolver!.GetPackageAsync(b);
+                                                      var items = await reader.GetItemsAsync();
+
+                                                      return (b, items);
+                                                  }).ToDictionaryAsync(b => b.b.Name, b => b,
+                                                                       StringComparer.OrdinalIgnoreCase);
+
+            var dependencies = new Dictionary<PackageDependency, IEnumerable<IPackageItem>>(
+                resolvedPackages.Values.SelectMany(b => b.items.Dependencies)
+                                .Where(b => !resolvedPackages.ContainsKey(b.Key.Name))
+                                .GroupBy(b => b.Key.Name)
+                                .Select(b => b.MaxBy(c => c.Key.Version)));
+
+            _loadContext = new("PackageManager Context");
+
+            var dependencyAssemblies = await dependencies.ToAsyncEnumerable().SelectAwait(async pair =>
+            {
+                var (dep, items) = pair;
+                var assemblies = await LoadAssembliesFromItems(items);
+
+                return (dep, assemblies);
+            }).ToDictionaryAsync(b => b.dep, b => b.assemblies);
+
+            var packageAssemblies = await resolvedPackages.Values.ToAsyncEnumerable().SelectAwait(async b =>
+            {
+                var assemblies = await LoadAssembliesFromItems(b.items.Root);
+
+                return (b.b, assemblies);
+            }).ToDictionaryAsync(b => b.b, b => b.assemblies);
+
+            foreach (var assembly in dependencyAssemblies.Values.Concat(packageAssemblies.Values).SelectMany(b => b))
+            {
+                TorchLauncher.RegisterAssembly(assembly);
+            }
+
+            foreach (var (package, assemblies) in packageAssemblies)
+            {
+                using var hash = MD5.Create();
+                hash.Initialize();
+                var guid = new Guid(hash.ComputeHash(Encoding.UTF8.GetBytes(package.Name)));
+                
+                _pluginManager.InstantiatePlugin(new()
+                {
+                    Name = package.Name,
+                    Version = package.Version.ToString(),
+                    Guid = guid
+                }, assemblies);
+            }
+
+            _packageAssemblies = packageAssemblies.ToImmutableDictionary();
+        }
+        finally
+        {
+            semaphore.Release();
+        }
+    }
+
+    private async Task<Assembly[]> LoadAssembliesFromItems(IEnumerable<IPackageItem> items)
+    {
+        var dictionary = items.ToImmutableDictionary(b => b.FileName, StringComparer.OrdinalIgnoreCase);
+
+        var assemblies = await dictionary
+                               .Where(b => Path.GetExtension(b.Key)
+                                               .Equals("dll", StringComparison.OrdinalIgnoreCase))
+                               .ToAsyncEnumerable()
+                               .SelectAwait(async b =>
+                               {
+                                   dictionary.TryGetValue(
+                                       Path.ChangeExtension(b.Key, "pdb"), out var pdbItem);
+                                   return await LoadFromStream(b.Key, b.Value, pdbItem);
+                               }).ToArrayAsync();
+        return assemblies;
+    }
+
+    private async ValueTask<Assembly> LoadFromStream(string key, IPackageItem dllItem, IPackageItem? pdbItem)
+    {
+        if (_loadContext is null)
+            throw new InvalidOperationException("Load Context should be initialized before calling the method");
+
+        Log.Trace("Loading {0}", key);
+        await using var dll = await dllItem.OpenFileAsync();
+        if (pdbItem is null)
+            return _loadContext.LoadFromStream(dll);
+
+        await using var pdb = await pdbItem.OpenFileAsync();
+        return _loadContext.LoadFromStream(dll, pdb);
+    }
+
+    private async Task ResolvePackagesAsync(IReadOnlyDictionary<string, string> requestedPackages)
+    {
+        Log.Info("Resolving packages");
+        var packages = await _packageResolver!.ResolvePackagesAsync(requestedPackages);
+
+        _packages = packages.ToImmutableHashSet();
+        Log.Info("Got {0} packages", _packages.Count);
+    }
+}

Torch/Patches/KeenLogPatch.cs

@@ -79,6 +79,9 @@ namespace Torch.Patches
         [ReflectedSetter(Name = "m_enabled")]
         private static Action<MyLog, bool> _enabledSetter = null!;
         
+        [ReflectedMethod(Type = typeof(MyLog), Name = "LogFlag")]
+        private static Func<MyLog, LoggingOptions, bool> _logFlag = null!;
+
         private static int GetIndentByCurrentThread()
         {
             using var l = _lockGetter(MyLog.Default).AcquireExclusiveUsing();
@@ -122,7 +125,7 @@ namespace Torch.Patches
         }
         private static bool PrefixWriteLineOptions(MyLog __instance, string message, LoggingOptions option)
         {
-            if (__instance.LogEnabled && __instance.LogFlag(option) && _log.IsDebugEnabled)
+            if (__instance.LogEnabled && _logFlag(__instance, option) && _log.IsDebugEnabled)
                 _log.Info($"{string.Empty.PadRight(3 * GetIndentByCurrentThread(), ' ')}{message}");
             return false;
         }

Torch/Patches/ModsDownloadingPatch.cs

@@ -10,6 +10,7 @@ using Torch.Managers.PatchManager;
 using Torch.Managers.PatchManager.MSIL;
 using Torch.Utils;
 using VRage.Game;
+using VRage.GameServices;
 
 namespace Torch.Patches
 {
@@ -31,7 +32,7 @@ namespace Torch.Patches
         }
         public static void Postfix(MyWorkshop.ResultData __result, List<MyObjectBuilder_Checkpoint.ModItem> mods)
         {
-            if (__result.Success) return;
+            if (__result.Result is MyGameServiceCallResult.OK) return;
             _log.Warn("Missing Mods:");
             var mismatchMods = mods.Where(b => __result.Mods.All(c => b.PublishedFileId != c.Id));
             foreach (var mod in mismatchMods)

Torch/Patches/ObjectFactoryInitPatch.cs

@@ -1,139 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Runtime.CompilerServices;
-using Sandbox;
-using Sandbox.Game.Entities;
-using Torch.Utils;
-using VRage.Game.Common;
-using VRage.Game.Components;
-using VRage.Game.Entity;
-using VRage.ObjectBuilders;
-using VRage.Plugins;
-using VRage.Utils;
-
-namespace Torch.Patches
-{
-
-    /// <summary>
-    /// There are places in static ctors where the registered assembly depends on the <see cref="Assembly.GetCallingAssembly"/>
-    /// or <see cref="MyPlugins"/>.  Here we force those registrations with the proper assemblies to ensure they work correctly.
-    /// </summary>
-    internal static class ObjectFactoryInitPatch
-    {
-#pragma warning disable 649
-        [ReflectedGetter(Name = "m_objectFactory", TypeName = "Sandbox.Game.Entities.MyEntityFactory, Sandbox.Game")]
-        private static Func<MyObjectFactory<MyEntityTypeAttribute, MyEntity>> EntityFactoryObjectFactory;
-#pragma warning restore 649
-
-        internal static void ForceRegisterAssemblies()
-        {
-            var userAssemblies = MyPlugins.UserAssemblies;
-            // static MyEntities() called by MySandboxGame.ForceStaticCtor
-            RuntimeHelpers.RunClassConstructor(typeof(MyEntities).TypeHandle);
-            {
-                MyObjectFactory<MyEntityTypeAttribute, MyEntity> factory = EntityFactoryObjectFactory();
-                ObjectFactory_RegisterFromAssemblySafe(factory, typeof(MySandboxGame).Assembly); // calling assembly
-                ObjectFactory_RegisterFromAssemblySafe(factory, MyPlugins.GameAssembly);
-                ObjectFactory_RegisterFromAssemblySafe(factory, MyPlugins.SandboxAssembly);
-                //ObjectFactory_RegisterFromAssemblySafe(factory, MyPlugins.UserAssembly);
-                if (userAssemblies != null)
-                {
-                    foreach (var assembly in userAssemblies)
-                    {
-                        ObjectFactory_RegisterFromAssemblySafe(factory, assembly);
-                    }
-                }
-            }
-
-            // static MyGuiManager():
-            // MyGuiControlsFactory.RegisterDescriptorsFromAssembly();
-
-            // static MyComponentTypeFactory() called by MyComponentContainer.Add
-            RuntimeHelpers.RunClassConstructor(typeof(MyComponentTypeFactory).TypeHandle);
-            {
-                ComponentTypeFactory_RegisterFromAssemblySafe(typeof(MyComponentContainer).Assembly); // calling assembly
-                ComponentTypeFactory_RegisterFromAssemblySafe(MyPlugins.SandboxAssembly);
-                ComponentTypeFactory_RegisterFromAssemblySafe(MyPlugins.GameAssembly);
-                ComponentTypeFactory_RegisterFromAssemblySafe(MyPlugins.SandboxGameAssembly);
-                //ComponentTypeFactory_RegisterFromAssemblySafe(MyPlugins.UserAssembly);
-                if (userAssemblies != null)
-                {
-                    foreach (var assembly in userAssemblies)
-                    {
-                        ComponentTypeFactory_RegisterFromAssemblySafe(assembly);
-                    }
-                }
-            }
-
-            MyEntities.Orchestrator = new MyParallelEntityUpdateOrchestrator();
-
-            // static MyObjectPoolManager()
-            // Render, so should be fine.
-        }
-
-        #region MyObjectFactory Adders
-        private static void ObjectFactory_RegisterDescriptorSafe<TAttribute, TCreatedObjectBase>(
-            MyObjectFactory<TAttribute, TCreatedObjectBase> factory, TAttribute descriptor, Type type) where TAttribute : MyFactoryTagAttribute where TCreatedObjectBase : class
-        {
-            if (factory.Attributes.TryGetValue(type, out _))
-                return;
-            if (descriptor.ObjectBuilderType != null && factory.TryGetProducedType(descriptor.ObjectBuilderType) != null)
-                return;
-            if (typeof(MyObjectBuilder_Base).IsAssignableFrom(descriptor.ProducedType) &&
-                factory.TryGetProducedType(descriptor.ProducedType) != null)
-                return;
-            factory.RegisterDescriptor(descriptor, type);
-        }
-
-        private static void ObjectFactory_RegisterFromAssemblySafe<TAttribute, TCreatedObjectBase>(MyObjectFactory<TAttribute, TCreatedObjectBase> factory, Assembly assembly) where TAttribute : MyFactoryTagAttribute where TCreatedObjectBase : class
-        {
-            if (assembly == null)
-            {
-                return;
-            }
-            foreach (Type type in assembly.GetTypes())
-            {
-                foreach (TAttribute descriptor in type.GetCustomAttributes<TAttribute>())
-                {
-                    ObjectFactory_RegisterDescriptorSafe(factory, descriptor, type);
-                }
-            }
-        }
-        #endregion
-        #region MyComponentTypeFactory Adders
-
-        [ReflectedGetter(Name = "m_idToType", Type = typeof(MyComponentTypeFactory))]
-        private static Func<Dictionary<MyStringId, Type>> ComponentTypeFactoryIdToType = null!;
-        [ReflectedGetter(Name = "m_typeToId", Type = typeof(MyComponentTypeFactory))]
-        private static Func<Dictionary<Type, MyStringId>> ComponentTypeFactoryTypeToId = null!;
-        [ReflectedGetter(Name = "m_typeToContainerComponentType", Type = typeof(MyComponentTypeFactory))]
-        private static Func<Dictionary<Type, Type>> ComponentTypeFactoryContainerComponentType = null!;
-
-        private static void ComponentTypeFactory_RegisterFromAssemblySafe(Assembly assembly)
-        {
-            if (assembly == null)
-                return;
-            foreach (Type type in assembly.GetTypes())
-                if (typeof(MyComponentBase).IsAssignableFrom(type))
-                {
-                    ComponentTypeFactory_AddIdSafe(type, MyStringId.GetOrCompute(type.Name));
-                    ComponentTypeFactory_RegisterComponentTypeAttributeSafe(type);
-                }
-        }
-
-        private static void ComponentTypeFactory_RegisterComponentTypeAttributeSafe(Type type)
-        {
-            Type componentType = type.GetCustomAttribute<MyComponentTypeAttribute>(true)?.ComponentType;
-            if (componentType != null)
-                ComponentTypeFactoryContainerComponentType()[type] = componentType;
-        }
-
-        private static void ComponentTypeFactory_AddIdSafe(Type type, MyStringId id)
-        {
-            ComponentTypeFactoryIdToType()[id] = type;
-            ComponentTypeFactoryTypeToId()[type] = id;
-        }
-        #endregion
-    }
-}

Torch/Patches/ScriptCompilerPatch.cs

@@ -58,10 +58,10 @@ namespace Torch.Patches
                 typeof(TypeConverter).Assembly.Location,
                 typeof(System.Diagnostics.TraceSource).Assembly.Location,
                 typeof(System.Security.Policy.Evidence).Assembly.Location,
-                typeof(ProtoBuf.Meta.RuntimeTypeModel).Assembly.Location,
+                Path.Combine(baseDir, "System.Xml.ReaderWriter.dll"),
-                typeof(ProtoContractAttribute).Assembly.Location,
                 Path.Combine(baseDir, "netstandard.dll"),
                 Path.Combine(baseDir, "System.Runtime.dll"),
+                Path.Combine(MyFileSystem.ExePath, "ProtoBuf.Net.Core.dll"),
                 Path.Combine(MyFileSystem.ExePath, "Sandbox.Game.dll"),
                 Path.Combine(MyFileSystem.ExePath, "Sandbox.Common.dll"),
                 Path.Combine(MyFileSystem.ExePath, "Sandbox.Graphics.dll"),
@@ -83,14 +83,6 @@ namespace Torch.Patches
 
             using var batch = MyScriptCompiler.Static.Whitelist.OpenBatch();
             batch.AllowTypes(MyWhitelistTarget.ModApi, typeof(ConcurrentQueue<>));
-            batch.AllowNamespaceOfTypes(MyWhitelistTarget.Both, typeof(ImmutableArray), typeof(ArrayExtensions));
-            batch.AllowTypes(MyWhitelistTarget.ModApi, typeof(ProtoContractAttribute).Assembly.GetExportedTypes()
-                                 .Where(b => b.Namespace == "ProtoBuf" && b.Name.Contains("Attribute"))
-                                 .Concat(new[]
-                                 {
-                                     typeof(DataFormat), typeof(MemberSerializationOptions), typeof(ImplicitFields)
-                                 }).ToArray());
-            batch.AllowTypes(MyWhitelistTarget.ModApi, typeof(WorkData));
             
             return false;
         }

Torch/Plugins/PluginManager.cs

@@ -52,7 +52,39 @@ namespace Torch.Managers
         /// <inheritdoc />
         public IReadOnlyDictionary<Guid, ITorchPlugin> Plugins => _plugins.AsReadOnlyObservable();
 
-        public event Action<IReadOnlyCollection<ITorchPlugin>> PluginsLoaded;
+        private Action<IReadOnlyCollection<ITorchPlugin>> _pluginsLoaded;
+        private bool _loaded;
+
+        public event Action<IReadOnlyCollection<ITorchPlugin>> PluginsLoaded
+        {
+            add
+            {
+                var action = _pluginsLoaded;
+                Action<IReadOnlyCollection<ITorchPlugin>> action2;
+                do
+                {
+                    action2 = action;
+                    var action3 = (Action<IReadOnlyCollection<ITorchPlugin>>)Delegate.Combine(action2, value);
+                    action = Interlocked.CompareExchange(ref _pluginsLoaded, action3, action2);
+                }
+                while (action != action2);
+
+                if (_loaded)
+                    value(_plugins.Values.AsReadOnly());
+            }
+            remove
+            {
+                var action = _pluginsLoaded;
+                Action<IReadOnlyCollection<ITorchPlugin>> action2;
+                do
+                {
+                    action2 = action;
+                    var action3 = (Action<IReadOnlyCollection<ITorchPlugin>>)Delegate.Remove(action2, value);
+                    action = Interlocked.CompareExchange(ref _pluginsLoaded, action3, action2);
+                }
+                while (action != action2);
+            }
+        }
 
         public PluginManager(ITorchBase torchInstance) : base(torchInstance)
         {
@@ -145,7 +177,8 @@ namespace Torch.Managers
                     plugin.Init(Torch);
                 }
                 _log.Info($"Loaded {_plugins.Count} plugins.");
-                PluginsLoaded?.Invoke(_plugins.Values.AsReadOnly());
+                _loaded = true;
+                _pluginsLoaded?.Invoke(_plugins.Values.AsReadOnly());
                 return;
             }
 
@@ -220,7 +253,8 @@ namespace Torch.Managers
                 plugin.Init(Torch);
             }
             _log.Info($"Loaded {_plugins.Count} plugins.");
-            PluginsLoaded?.Invoke(_plugins.Values.AsReadOnly());
+            _loaded = true;
+            _pluginsLoaded?.Invoke(_plugins.Values.AsReadOnly());
         }
 
         //debug flag is set when the user asks us to run with a specific plugin for plugin development debug
@@ -386,11 +420,7 @@ namespace Torch.Managers
             }
 
             var harmonyAssembly = assemblies.FirstOrDefault(b => b.FullName?.StartsWith("0Harmony") == true);
-            if (harmonyAssembly is { })
+            if (harmonyAssembly is { }) assemblies.Remove(harmonyAssembly);
-            {
-                _log.Warn($"Plugin {item.Manifest.Name} is using harmony library, logic collision between plugins could be encountered!");
-                assemblies.Remove(harmonyAssembly);
-            }
 
             RegisterAllAssemblies(assemblies);
             InstantiatePlugin(item.Manifest, assemblies);
@@ -432,7 +462,7 @@ namespace Torch.Managers
             return a.Name == b.Name && b.Version >= a.Version;
         }
 
-        private void InstantiatePlugin(PluginManifest manifest, IEnumerable<Assembly> assemblies)
+        internal void InstantiatePlugin(PluginManifest manifest, IEnumerable<Assembly> assemblies)
         {
             Type pluginType = null;
             bool mult = false;

Torch/Session/TorchSessionManager.cs

@@ -49,8 +49,6 @@ namespace Torch.Session
         public TorchSessionManager(ITorchBase torchInstance) : base(torchInstance)
         {
             _overrideMods = new Dictionary<ulong, MyObjectBuilder_Checkpoint.ModItem>();
-            if (Torch.Config.UgcServiceType == UGCServiceType.Steam)
-                _overrideMods.Add(TorchModCore.MOD_ID, ModItemUtils.Create(TorchModCore.MOD_ID));
         }
 
         /// <inheritdoc/>
@@ -74,7 +72,9 @@ namespace Torch.Session
         {
             if (_overrideMods.ContainsKey(modId))
                 return false;
-            var item = ModItemUtils.Create(modId);
+#pragma warning disable CS0618
+            var item = ModItemUtils.Create(modId, TorchBase.Instance.Config.UgcServiceType.ToString());
+#pragma warning restore CS0618
             _overrideMods.Add(modId, item);
 
             OverrideModsChanged?.Invoke(new CollectionChangeEventArgs(CollectionChangeAction.Add, item));
@@ -193,6 +193,8 @@ namespace Torch.Session
             MySession.AfterLoading += SessionLoaded;
             MySession.OnUnloading += SessionUnloading;
             MySession.OnUnloaded += SessionUnloaded;
+            if (Torch.Config.UgcServiceType == UGCServiceType.Steam)
+                _overrideMods.Add(ModCommunication.MOD_ID, ModItemUtils.Create(ModCommunication.MOD_ID));
         }
 
 

Torch/Torch.csproj

@@ -13,6 +13,7 @@
     <Platforms>AnyCPU</Platforms>
     <EnableWindowsTargeting>true</EnableWindowsTargeting>
     <RestorePackagesWithLockFile>true</RestorePackagesWithLockFile>
+    <DefineConstants>TRACE;TORCH</DefineConstants>
   </PropertyGroup>
   
   <PropertyGroup Condition="$(Configuration) == 'Release'">
@@ -22,19 +23,19 @@
   <Import Project="..\Torch.Mod\Torch.Mod.projitems" Label="Shared" />
   
   <ItemGroup>
-    <PackageReference Include="ControlzEx" Version="5.0.2" />
+    <PackageReference Include="ControlzEx" Version="6.0.0" />
-    <PackageReference Include="HarmonyX" Version="2.10.2-prerelease.1" />
+    <PackageReference Include="HarmonyX" Version="2.10.2-prerelease.6" />
     <PackageReference Include="InfoOf.Fody" Version="2.1.1" PrivateAssets="all" />
     <PackageReference Include="MahApps.Metro" Version="2.4.9" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Common" Version="4.4.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Common" Version="4.6.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.6.0" />
-    <PackageReference Include="MonoModReorg.RuntimeDetour" Version="22.11.21-prerelease.2" />
+    <PackageReference Include="MonoMod.RuntimeDetour" Version="25.0.0" />
-    <PackageReference Include="NLog" Version="5.1.0" />
+    <PackageReference Include="NLog" Version="5.2.2" />
     <PackageReference Include="PropertyChanged.Fody" Version="4.1.0" PrivateAssets="all" />
-    <PackageReference Include="protobuf-net" Version="3.1.26" />
+    <PackageReference Include="protobuf-net" Version="3.2.26" />
     <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
     <PackageReference Include="Torch.SixLabors.ImageSharp" Version="1.0.0-beta6" />
-    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.201.13">
+    <PackageReference Include="SpaceEngineersDedicated.ReferenceAssemblies" Version="1.203.22">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>compile</IncludeAssets>
     </PackageReference>

Torch/TorchBase.cs

@@ -1,17 +1,16 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Configuration;
 using NLog;
 using Sandbox;
 using Sandbox.Game;
 using Sandbox.Game.Multiplayer;
 using Sandbox.Game.Screens.Helpers;
-using SpaceEngineers.Game;
 using Torch.API;
 using Torch.API.Managers;
 using Torch.API.ModAPI;
@@ -21,10 +20,10 @@ using Torch.Event;
 using Torch.Managers;
 using Torch.Managers.ChatManager;
 using Torch.Managers.PatchManager;
+using Torch.Packages;
 using Torch.Patches;
 using Torch.Utils;
 using Torch.Session;
-using VRage.Platform.Windows;
 using VRage.Plugins;
 using VRage.Utils;
 
@@ -61,6 +60,8 @@ namespace Torch
         /// <inheritdoc />
         public ITorchConfig Config { get; protected set; }
 
+        public abstract IConfiguration Configuration { get; }
+
         /// <inheritdoc />
         public SemanticVersioning.Version TorchVersion { get; }
         public string InstancePath { get; protected init;}
@@ -116,17 +117,20 @@ namespace Torch
 #pragma warning restore CS0618
 
             var sessionManager = new TorchSessionManager(this);
-            sessionManager.AddFactory((x) => Sync.IsServer ? new ChatManagerServer(this) : new ChatManagerClient(this));
+            sessionManager.AddFactory(_ => Sync.IsServer ? new ChatManagerServer(this) : new ChatManagerClient(this));
-            sessionManager.AddFactory((x) => Sync.IsServer ? new CommandManager(this) : null);
+            sessionManager.AddFactory(_ => Sync.IsServer ? new CommandManager(this) : null);
-            sessionManager.AddFactory((x) => new EntityManager(this));
+            sessionManager.AddFactory(_ => new EntityManager(this));
 
             Managers.AddManager(sessionManager);
             Managers.AddManager(new PatchManager(this));
             Managers.AddManager(new FilesystemManager(this));
+#if !DEBUG
             Managers.AddManager(new UpdateManager(this)); 
+#endif
             Managers.AddManager(new EventManager(this));
 #pragma warning disable CS0618
             Managers.AddManager(Plugins);
+            Managers.AddManager(new PackageManager(this, (PluginManager)Plugins));
 #pragma warning restore CS0618
             Managers.AddManager(new ScriptCompilationManager(this));
             TorchAPI.Instance = this;
@@ -134,13 +138,7 @@ namespace Torch
             GameStateChanged += (game, state) =>
             {
                 if (state == TorchGameState.Created) 
-                {
-                    // If the attached assemblies change (MySandboxGame.ctor => MySandboxGame.ParseArgs => MyPlugins.RegisterFromArgs)
-                    // attach assemblies to object factories again.
-                    ObjectFactoryInitPatch.ForceRegisterAssemblies();
-                    // safe to commit here; all important static ctors have run
                     PatchManager.CommitInternal();
-                }
             };
 
             var harmonyLog = LogManager.GetLogger("HarmonyX");
@@ -260,7 +258,6 @@ namespace Torch
         public virtual void Init()
         {
             Debug.Assert(!_init, "Torch instance is already initialized.");
-            ObjectFactoryInitPatch.ForceRegisterAssemblies();
             VRageGame.SetupVersionInfo();
 
             Debug.Assert(MyPerGameSettings.BasicGameInfo.GameVersion != null, "MyPerGameSettings.BasicGameInfo.GameVersion != null");
@@ -286,6 +283,11 @@ namespace Torch
             Log.Info($"Executing directory: {AppDomain.CurrentDomain.BaseDirectory}");
 
             Managers.GetManager<PluginManager>().LoadPlugins();
+
+            var semaphore = new SemaphoreSlim(0, 1);
+            Managers.GetManager<PackageManager>().LoadAsync(semaphore);
+            semaphore.Wait();
+
             Game = new VRageGame(this, TweakGameSettings, SteamAppName, SteamAppId, InstancePath, RunArgs);
             if (!Game.WaitFor(VRageGame.GameState.Stopped))
                 Log.Warn("Failed to wait for game to be initialized");
@@ -370,10 +372,10 @@ namespace Torch
         /// <inheritdoc />
         public virtual void Stop()
         {
-            LogManager.Flush();
             Game.SignalStop();
-            if (!Game.WaitFor(VRageGame.GameState.Stopped))
+            if (!Game.WaitFor(VRageGame.GameState.Stopped, TimeSpan.FromSeconds(Config.TickTimeout)))
                 Log.Warn("Failed to wait for the game to be stopped");
+            LogManager.Flush();
         }
 
         /// <inheritdoc />

Torch/Utils/TorchLauncher.cs

@@ -47,7 +47,7 @@ namespace Torch.Utils
         
         private static void CopyNative()
         {
-            if (ApplicationContext.Current.GameFilesDirectory.Attributes.HasFlag(FileAttributes.ReadOnly))
+            if (ApplicationContext.Current.IsService || ApplicationContext.Current.GameFilesDirectory.Attributes.HasFlag(FileAttributes.ReadOnly))
             {
                 Log.Warn("Torch directory is readonly. You should copy steam_api64.dll, Havok.dll from bin manually");
                 return;

Torch/VRageGame.cs

@@ -8,6 +8,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Havok;
+using Microsoft.Extensions.Configuration;
 using NLog;
 using NLog.Fluent;
 using Sandbox;
@@ -30,6 +31,7 @@ using VRage.Dedicated;
 using VRage.EOS;
 using VRage.FileSystem;
 using VRage.Game;
+using VRage.Game.ModAPI;
 using VRage.Game.ObjectBuilder;
 using VRage.Game.SessionComponents;
 using VRage.GameServices;
@@ -165,11 +167,14 @@ namespace Torch
             _tweakGameSettings();
 
             MyFileSystem.Reset();
-            MyInitializer.InvokeBeforeRun(_appSteamId, _appName, _userDataPath);
+            MyInitializer.InvokeBeforeRun(_appSteamId, _appName, MyVRage.Platform.System.GetRootPath(), _userDataPath);
 
             _log.Info("Loading Dedicated Config");
+            
             // object created in SpaceEngineersGame.SetupPerGameSettings()
             MySandboxGame.ConfigDedicated.Load();
+            ApplyConfiguration(MySandboxGame.ConfigDedicated);
+            
             MyPlatformGameSettings.CONSOLE_COMPATIBLE = MySandboxGame.ConfigDedicated.ConsoleCompatibility;
 
             //Type.GetType("VRage.Steam.MySteamService, VRage.Steam").GetProperty("IsActive").GetSetMethod(true).Invoke(service, new object[] {SteamAPI.Init()});
@@ -193,7 +198,7 @@ namespace Torch
             {
                 service = MyEOSService.Create();
 
-                MyEOSService.InitNetworking(dedicated,
+                MyEOSService.InitNetworking(dedicated, true, //true because using Eos
                     "Space Engineers",
                     service,
                     "xyza7891A4WeGrpP85BTlBa3BSfUEABN",
@@ -225,7 +230,8 @@ namespace Torch
             
             MyGameService.WorkshopService.AddAggregate(MyModIoService.Create(service, "spaceengineers", "264",
                 "1fb4489996a5e8ffc6ec1135f9985b5b", "331", "f2b64abe55452252b030c48adc0c1f0e",
-                MyPlatformGameSettings.UGC_TEST_ENVIRONMENT, true));
+                MyPlatformGameSettings.UGC_TEST_ENVIRONMENT, true, MyPlatformGameSettings.MODIO_PLATFORM,
+                MyPlatformGameSettings.MODIO_PORTAL));
             
             if (!isEos && !MyGameService.HasGameServer)
             {
@@ -300,6 +306,18 @@ namespace Torch
             MyGlobalTypeMetadata.Static.Init(false);
         }
 
+        private void ApplyConfiguration(IMyConfigDedicated dedicated)
+        {
+            var config = _torch.Configuration.GetSection("DedicatedServer");
+
+            dedicated.ServerPort = config.GetValue("Port", dedicated.ServerPort);
+            dedicated.ConsoleCompatibility = config.GetValue("ConsoleCompatibility", dedicated.ConsoleCompatibility);
+            dedicated.IP = config.GetValue("Ip", dedicated.IP);
+            dedicated.WorldName = config.GetValue("WorldName", dedicated.WorldName);
+            dedicated.ServerName = config.GetValue("ServerName", dedicated.ServerName);
+            dedicated.ServerDescription = config.GetValue("ServerDescription", dedicated.ServerDescription);
+        }
+
         private void Destroy()
         {
             _game.Dispose();

Torch/packages.lock.json

@@ -4,23 +4,21 @@
     "net7.0-windows7.0": {
       "ControlzEx": {
         "type": "Direct",
-        "requested": "[5.0.2, )",
+        "requested": "[6.0.0, )",
-        "resolved": "5.0.2",
+        "resolved": "6.0.0",
-        "contentHash": "f724LoDJ36LxaLR62G4ek9ZAJI8BiiYRJJ04furC/qjXSeIwU0qmHFIe19xB1/FwxyZjevdFguEr9ZUjf3dZgw==",
+        "contentHash": "MEaqj6ienvKR4E7QJ3vwzo2vrdy2Kqw9Z3CudY5iUixR5iMYeLoMlks7EiABsz4WqDsgVLd9u7fixmCOGU+4ow==",
         "dependencies": {
-          "Microsoft.Xaml.Behaviors.Wpf": "1.1.31",
+          "Microsoft.Xaml.Behaviors.Wpf": "1.1.39",
-          "System.Text.Json": "5.0.1"
+          "System.Text.Json": "5.0.2"
         }
       },
       "HarmonyX": {
         "type": "Direct",
-        "requested": "[2.10.2-prerelease.1, )",
+        "requested": "[2.10.2-prerelease.6, )",
-        "resolved": "2.10.2-prerelease.1",
+        "resolved": "2.10.2-prerelease.6",
-        "contentHash": "5hbH0ENhQ+JV7tk63fQ2ab7MtplRHKJYH1JfIjG39rlltHNXxAcGJh05an+SQbVRV4EoP/+Qm9w9BrLc3RwRMA==",
+        "contentHash": "CPCUR/t5AQ5DDs40bTJ5OwUVTCoZONaJGbWKKjAOwg7c7Ct4KEbfybH6T+KvRGVjf5eN1oyGY5BN7EfWxUh9Xg==",
         "dependencies": {
-          "MonoModReorg.RuntimeDetour": "22.11.21-prerelease.2",
+          "MonoMod.RuntimeDetour": "25.0.0"
-          "System.Reflection.Emit": "4.7.0",
-          "System.Reflection.Emit.Lightweight": "4.7.0"
         }
       },
       "InfoOf.Fody": {
@@ -43,46 +41,44 @@
       },
       "Microsoft.CodeAnalysis.Common": {
         "type": "Direct",
-        "requested": "[4.4.0, )",
+        "requested": "[4.6.0, )",
-        "resolved": "4.4.0",
+        "resolved": "4.6.0",
-        "contentHash": "JfHupS/B7Jb5MZoYkFFABn3mux0wQgxi2D8F/rJYZeRBK2ZOyk7TjQ2Kq9rh6W/DCh0KNbbSbn5qoFar+ueHqw==",
+        "contentHash": "N3uLvekc7DjvE1BX8YW7UH7ldjA4ps/Tun2YmOoSIItJrh1gnQIMKUbK1c3uQUx2NHbLibVZI4o/VB9xb4B7tA==",
         "dependencies": {
-          "Microsoft.CodeAnalysis.Analyzers": "3.3.3",
+          "Microsoft.CodeAnalysis.Analyzers": "3.3.4",
-          "System.Collections.Immutable": "6.0.0",
+          "System.Collections.Immutable": "7.0.0",
-          "System.Memory": "4.5.5",
+          "System.Reflection.Metadata": "7.0.0",
-          "System.Reflection.Metadata": "5.0.0",
           "System.Runtime.CompilerServices.Unsafe": "6.0.0",
-          "System.Text.Encoding.CodePages": "6.0.0",
+          "System.Text.Encoding.CodePages": "7.0.0"
-          "System.Threading.Tasks.Extensions": "4.5.4"
         }
       },
       "Microsoft.CodeAnalysis.CSharp": {
         "type": "Direct",
-        "requested": "[4.4.0, )",
+        "requested": "[4.6.0, )",
-        "resolved": "4.4.0",
+        "resolved": "4.6.0",
-        "contentHash": "eD2w0xHRoaqK07hjlOKGR9eLNy3nimiGNeCClNax1NDgS/+DBtBqCjXelOa+TNy99kIB3nHhUqDmr46nDXy/RQ==",
+        "contentHash": "9pyFZUN2Lyu3C0Xfs49kezfH+CzQHMibGsQeQPu0P+GWyH2XXDwmyZ6jAaKQGNUXOJfC2OK01hWMJTJY315uDQ==",
         "dependencies": {
-          "Microsoft.CodeAnalysis.Common": "[4.4.0]"
+          "Microsoft.CodeAnalysis.Common": "[4.6.0]"
         }
       },
-      "MonoModReorg.RuntimeDetour": {
+      "MonoMod.RuntimeDetour": {
         "type": "Direct",
-        "requested": "[22.11.21-prerelease.2, )",
+        "requested": "[25.0.0, )",
-        "resolved": "22.11.21-prerelease.2",
+        "resolved": "25.0.0",
-        "contentHash": "Qv1h4rW03LrHwxwVuw5R6hbL8X78l8Lfnxe5tMlyVAe+AK0HnwsRzjsTwzFF57wxWUwq12NbLflkzV6T+hIhJw==",
+        "contentHash": "u+G34uSEjU0+fk4Iz3Mfws/+E4kW460i6fBz1b4L/yxSndfmdKkJ+pYbU9pwh7IUxgk0Ko0+Mx3fSUQPaNk8nA==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "22.11.21-prerelease.2",
+          "MonoMod.Backports": "1.0.0",
-          "MonoModReorg.Core": "22.11.21-prerelease.2",
+          "MonoMod.Core": "1.0.0",
-          "MonoModReorg.ILHelpers": "22.11.21-prerelease.2",
+          "MonoMod.ILHelpers": "1.0.0",
-          "MonoModReorg.Utils": "22.11.21-prerelease.2"
+          "MonoMod.Utils": "25.0.0"
         }
       },
       "NLog": {
         "type": "Direct",
-        "requested": "[5.1.0, )",
+        "requested": "[5.2.2, )",
-        "resolved": "5.1.0",
+        "resolved": "5.2.2",
-        "contentHash": "oW7ekrkRG9okpDMUcEglunWj8Qf2RY8qkgl+/chJoavzg3dbT13y32t19R54FKkmq80fKzw4ZekZkCrRGanKgQ=="
+        "contentHash": "r6Q9740g29gTwmTWlsgdIFm0mhNsfNZmbvWKX/Fxmi8X89ZrpUowHM2T2X1lP7RVpND+ef+XnfKL5g6Q1iNGXA=="
       },
       "PropertyChanged.Fody": {
         "type": "Direct",
@@ -95,18 +91,18 @@
       },
       "protobuf-net": {
         "type": "Direct",
-        "requested": "[3.1.26, )",
+        "requested": "[3.2.26, )",
-        "resolved": "3.1.26",
+        "resolved": "3.2.26",
-        "contentHash": "iy+VROYtWZEqDvkUjS6FfzKZNpWRoVGc5h0cupGQT/37Ox0LxPblRKLnw6V0RT1MPclLo8nZp7E2M0f7PNn/Tw==",
+        "contentHash": "zBzBiKs4yP+tzQOsRA5WbI/zayS6eFv8g0KIKNPI7/RUY1nk9Oe+STmtbUYkNUkO3T3SidEoZv+tF1nmgTSutQ==",
         "dependencies": {
-          "protobuf-net.Core": "3.1.26"
+          "protobuf-net.Core": "3.2.26"
         }
       },
       "SpaceEngineersDedicated.ReferenceAssemblies": {
         "type": "Direct",
-        "requested": "[1.201.13, )",
+        "requested": "[1.203.22, )",
-        "resolved": "1.201.13",
+        "resolved": "1.203.22",
-        "contentHash": "FRXuNLENsz5jGQvL0QkogAGsxEJyUQlXhvWHBWfZiHCnCrAWMD60nEis6yt0xCQpazszfMtHonbxz72XMxnFoQ==",
+        "contentHash": "ruf6DT1sAh2DnpsJUsGG4ZSdPKrVr5ReKfHSDcYggeacge/nsdqpcij53HSNwnMxve6cfnTRG9SXE2iGSGEtEQ==",
         "dependencies": {
           "protobuf-net": "1.0.0"
         }
@@ -137,59 +133,199 @@
         "resolved": "0.9.0",
         "contentHash": "xCqODS+wzpUXNtg4bMMvXG5PLbP0iTwRzRn2R+zWHKm83E6tbV2bCagawXp1EnZeNpd5OXpMxehulZWns8efzQ=="
       },
+      "Microsoft.Bcl.AsyncInterfaces": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "UcSjPsst+DfAdJGVDsu346FX0ci0ah+lw3WRtn18NUwEqRt70HaOQ7lI72vy3+1LxtqI3T5GWwV39rQSrCzAeg=="
+      },
       "Microsoft.CodeAnalysis.Analyzers": {
         "type": "Transitive",
-        "resolved": "3.3.3",
+        "resolved": "3.3.4",
-        "contentHash": "j/rOZtLMVJjrfLRlAMckJLPW/1rze9MT1yfWqSIbUPGRu1m1P0fuo9PmqapwsmePfGB5PJrudQLvmUOAMF0DqQ=="
+        "contentHash": "AxkxcPR+rheX0SmvpLVIGLhOUXAKG56a64kV9VQZ4y9gR9ZmPXnqZvHJnmwLSwzrEP6junUF11vuc+aqo5r68g=="
+      },
+      "Microsoft.Extensions.Configuration.Abstractions": {
+        "type": "Transitive",
+        "resolved": "7.0.0",
+        "contentHash": "f34u2eaqIjNO9YLHBz8rozVZ+TcFiFs0F3r7nUJd7FRkVSxk8u4OpoK226mi49MwexHOR2ibP9MFvRUaLilcQQ==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "7.0.0"
+        }
+      },
+      "Microsoft.Extensions.Configuration.Binder": {
+        "type": "Transitive",
+        "resolved": "7.0.4",
+        "contentHash": "8+XPvJnHZsYgHOQlcMuQe7QNF5KdVKHH1F/wW3nd8/u81Gk/XFAYMDP0Lpz18h7/AM95M662vvqMorcYxCBB4w==",
+        "dependencies": {
+          "Microsoft.Extensions.Configuration.Abstractions": "7.0.0"
+        }
+      },
+      "Microsoft.Extensions.FileProviders.Abstractions": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "0pd4/fho0gC12rQswaGQxbU34jOS1TPS8lZPpkFCH68ppQjHNHYle9iRuHeev1LhrJ94YPvzcRd8UmIuFk23Qw==",
+        "dependencies": {
+          "Microsoft.Extensions.Primitives": "6.0.0"
+        }
+      },
+      "Microsoft.Extensions.FileSystemGlobbing": {
+        "type": "Transitive",
+        "resolved": "6.0.0",
+        "contentHash": "ip8jnL1aPiaPeKINCqaTEbvBFDmVx9dXQEBZ2HOBRXPD1eabGNqP/bKlsIcp7U2lGxiXd5xIhoFcmY8nM4Hdiw=="
+      },
+      "Microsoft.Extensions.Primitives": {
+        "type": "Transitive",
+        "resolved": "7.0.0",
+        "contentHash": "um1KU5kxcRp3CNuI8o/GrZtD4AIOXDk+RLsytjZ9QPok3ttLUelLKpilVPuaFT3TFjOhSibUAso0odbOaCDj3Q=="
       },
       "Microsoft.Xaml.Behaviors.Wpf": {
         "type": "Transitive",
-        "resolved": "1.1.31",
+        "resolved": "1.1.39",
-        "contentHash": "LZpuf82ACZWldmfMuv3CTUMDh3o0xo0uHUaybR5HgqVLDBJJ9RZLykplQ/bTJd0/VDt3EhD4iDgUgbdIUAM+Kg=="
+        "contentHash": "8PZKqw9QOcu42xk8puY4P1+EXHL9YGOR9b7qhaYx5cILHul456H073tj99vyPcCt0W0781T9RwHqkx507ZyUpQ=="
       },
       "Mono.Cecil": {
         "type": "Transitive",
         "resolved": "0.11.4",
         "contentHash": "IC1h5g0NeJGHIUgzM1P82ld57knhP0IcQfrYITDPXlNpMYGUrsG5TxuaWTjaeqDNQMBDNZkB8L0rBnwsY6JHuQ=="
       },
-      "MonoModReorg.Backports": {
+      "MonoMod.Backports": {
         "type": "Transitive",
-        "resolved": "22.11.21-prerelease.2",
+        "resolved": "1.0.0",
-        "contentHash": "69T6jjA5nx29jLkdqtfXKlJ8sMqIlc6czNDTomy0rbM68W0xo2JRJBgsu2mroBuqx7nvUdX+zIU6k1edS/pPbw==",
+        "contentHash": "J59I4CMe24aCmWboHCDzQIk37kXqHnJH6KQfDGstlznuDni7Lwdd/8CywmEwVXjVEgfs5yQzvOTW3Xg1NH7fDQ==",
         "dependencies": {
-          "MonoModReorg.ILHelpers": "22.11.21-prerelease.2"
+          "MonoMod.ILHelpers": "1.0.0"
         }
       },
-      "MonoModReorg.Core": {
+      "MonoMod.Core": {
         "type": "Transitive",
-        "resolved": "22.11.21-prerelease.2",
+        "resolved": "1.0.0",
-        "contentHash": "gDoxu4aAF6TeOo8rsrj5prq2X36i12ch6NeRHu/Ct0H3qoPDHuEQ6JMJN/Eiy45YrLNEN7C5+Ku4BrNX4nwVQg==",
+        "contentHash": "FlzAEa4ujbA1t3rbKxuW3DP36T0/L6k2IP1F4QXM1cOXMJLHm39Azjt98E/9LFRFBWYFdlMUmg+4THLv2xyisA==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "22.11.21-prerelease.2",
+          "MonoMod.Backports": "1.0.0",
-          "MonoModReorg.ILHelpers": "22.11.21-prerelease.2",
+          "MonoMod.ILHelpers": "1.0.0",
-          "MonoModReorg.Utils": "22.11.21-prerelease.2"
+          "MonoMod.Utils": "25.0.0"
         }
       },
-      "MonoModReorg.ILHelpers": {
+      "MonoMod.ILHelpers": {
         "type": "Transitive",
-        "resolved": "22.11.21-prerelease.2",
+        "resolved": "1.0.0",
-        "contentHash": "JtOKHJR4DEyq3HxmdEVXIxhqNQnu1KmjGFXuEQrNHoPbzi8Yr9465VKVXdsoAF0Lm8StdyJHQ03efjv3+OlonA=="
+        "contentHash": "dTjGA+dYl7W5yQ0oG/Wr57tsa+ueoFUrwPtz9MZF9iheun4n70u7lge52F8UJi9i0zMHRfS2mAY6+nPuRZHQyQ=="
       },
-      "MonoModReorg.Utils": {
+      "MonoMod.Utils": {
         "type": "Transitive",
-        "resolved": "22.11.21-prerelease.2",
+        "resolved": "25.0.0",
-        "contentHash": "TX+vlgg2/x8rzEOqwiAy2qv61FjlJsr4u10WGTekCkulZVmmC+xxDmK+4Do9noXF/4RlgFN6sR3m9/W8KvJq3g==",
+        "contentHash": "E8m0pH3Kact+A2qH+lxMis90K8+ixInwprn0R1nuAMRHfotHUHeYmr304UEPeInSuY3+IlnC+OB8fqbQiTsWlQ==",
         "dependencies": {
           "Mono.Cecil": "0.11.4",
-          "MonoModReorg.Backports": "22.11.21-prerelease.2",
+          "MonoMod.Backports": "1.0.0",
-          "MonoModReorg.ILHelpers": "22.11.21-prerelease.2"
+          "MonoMod.ILHelpers": "1.0.0"
         }
       },
+      "Newtonsoft.Json": {
+        "type": "Transitive",
+        "resolved": "13.0.1",
+        "contentHash": "ppPFpBcvxdsfUonNcvITKqLl3bqxWbDCZIzDWHzjpdAHRFfZe0Dw9HmA0+za13IdyrgJwpkDTDA9fHaxOrt20A=="
+      },
+      "NuGet.Commands": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "D1b7gTk1wp7sxscLhS8O/yoErsRVbR4zJvLVD4jo1sgxh42ZOWKpMkhznPUxpvmCxBhw9hAy8/yWrRH91SfdEQ==",
+        "dependencies": {
+          "Microsoft.Extensions.FileProviders.Abstractions": "6.0.0",
+          "Microsoft.Extensions.FileSystemGlobbing": "6.0.0",
+          "NuGet.Credentials": "6.6.1",
+          "NuGet.ProjectModel": "6.6.1"
+        }
+      },
+      "NuGet.Common": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "hW5NtShErO3qbdkyv7doCRsFNK9Rlcc7mVjYM+hg1sOAWheTh/oo95DzNbsZthiqyHZfaioopfWtzmoxNw9h4g==",
+        "dependencies": {
+          "NuGet.Frameworks": "6.6.1"
+        }
+      },
+      "NuGet.Configuration": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "9WbK8wgwPfRpSwuG+ZhMshE48qUYvPIw7VNLCncrq/in4vE6SGsuawPSxPJkkLBtcKTGbPMez5JDvUf6vEBgKg==",
+        "dependencies": {
+          "NuGet.Common": "6.6.1",
+          "System.Security.Cryptography.ProtectedData": "4.4.0"
+        }
+      },
+      "NuGet.Credentials": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "TuOlXcE1ajwdtfnQaUjDv2xO2u/WDS56/b5jHfEBZetKfcpT0W3iNOqInVPO0qxRxXK5/HXUKVr2Pya1LsVVnA==",
+        "dependencies": {
+          "NuGet.Protocol": "6.6.1"
+        }
+      },
+      "NuGet.DependencyResolver.Core": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "K+EXXLU37PBnwLGx6WnVGxlfWYkdedvUUOeDMERXelNgjg20irtKf3hk+wGB7NmxAdNY9/gGcOgSDOV+M0w3Jg==",
+        "dependencies": {
+          "NuGet.Configuration": "6.6.1",
+          "NuGet.LibraryModel": "6.6.1",
+          "NuGet.Protocol": "6.6.1"
+        }
+      },
+      "NuGet.Frameworks": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "iRtDhL0zPqVw037fHEK9bQljTKPuOHhfIkz86/IH2P8eetr910HTTe5G8lJTuzZHh592Ze/sYhh173HIFjPSfg=="
+      },
+      "NuGet.LibraryModel": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "B0KH19sNNUq56YfEozIsIpk8EOyolG0LRT+hqG1/mhuXlQFiP9BgT6pZgwLQVLUl9YBDx3+KWQQbl6pz8Yh/Sw==",
+        "dependencies": {
+          "NuGet.Common": "6.6.1",
+          "NuGet.Versioning": "6.6.1"
+        }
+      },
+      "NuGet.Packaging": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "GwhFi2Ep4YzAGQFYz1OsMVNfiJ1M46nyCgHQ7xjJSMvxDYFgodR1RqVugWFMbIUUq6I8iYASwp5lpHXvITeuIQ==",
+        "dependencies": {
+          "Newtonsoft.Json": "13.0.1",
+          "NuGet.Configuration": "6.6.1",
+          "NuGet.Versioning": "6.6.1",
+          "System.Security.Cryptography.Cng": "5.0.0",
+          "System.Security.Cryptography.Pkcs": "5.0.0"
+        }
+      },
+      "NuGet.ProjectModel": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "CEyRXXvgIoEQBWn3WZupjkIVC6rPcGUAO5p4Gz+fnF8kcefWQOXHfnOE+UKZ0WwAJG5iMWRvXBKAGOuFiFhNpQ==",
+        "dependencies": {
+          "NuGet.DependencyResolver.Core": "6.6.1"
+        }
+      },
+      "NuGet.Protocol": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "HhKLsK6Q0NNp6qb0T26GLR5gCTRZu+gzqDVK4xqXHZmsolaDVIdIYpn44b2etaVYLzNJCvgRkw+I422u2bIvMw==",
+        "dependencies": {
+          "NuGet.Packaging": "6.6.1"
+        }
+      },
+      "NuGet.Versioning": {
+        "type": "Transitive",
+        "resolved": "6.6.1",
+        "contentHash": "Wm/AOFICTIrCgbVxv9dNWusraTzcggbo5W4ao7hD8NNVq911an9TGwW+uNuYc8I5PkpTeMuSXneV2u6hbi1P4w=="
+      },
       "protobuf-net.Core": {
         "type": "Transitive",
-        "resolved": "3.1.26",
+        "resolved": "3.2.26",
-        "contentHash": "fuKoDWgAf5ju+ixbJoasVFhnUaT0oWUgrWh1AZ5D0Y5keKHpA93vQB5g6aQNtB4zgeQ4hGEeh0MY9bIbAUPgEw=="
+        "contentHash": "s8oJW9dBVxix4p8uqMbeG++DIGjgzOFAKoP2i5wayeeFOKBqG+cCBO2S/CAC4MAFlb5m1Os2m/miLcqRCgqJ7Q==",
+        "dependencies": {
+          "System.Collections.Immutable": "7.0.0"
+        }
       },
       "SemanticVersioning": {
         "type": "Transitive",
@@ -206,61 +342,77 @@
       },
       "System.Collections.Immutable": {
         "type": "Transitive",
-        "resolved": "6.0.0",
+        "resolved": "7.0.0",
-        "contentHash": "l4zZJ1WU2hqpQQHXz1rvC3etVZN+2DLmQMO79FhOTZHMn8tDRr+WU287sbomD0BETlmKDn0ygUgVy9k5xkkJdA==",
+        "contentHash": "dQPcs0U1IKnBdRDBkrCTi1FoajSTBzLcVTpjO4MBCMC7f4pDOIPzgBoX8JjG7X6uZRJ8EBxsi8+DR1JuwjnzOQ=="
+      },
+      "System.Formats.Asn1": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "MTvUIktmemNB+El0Fgw9egyqT9AYSIk6DTJeoDSpc3GIHxHCMo8COqkWT1mptX5tZ1SlQ6HJZ0OsSvMth1c12w=="
+      },
+      "System.Linq.Async": {
+        "type": "Transitive",
+        "resolved": "6.0.1",
+        "contentHash": "0YhHcaroWpQ9UCot3Pizah7ryAzQhNvobLMSxeDIGmnXfkQn8u5owvpOH0K6EVB+z9L7u6Cc4W17Br/+jyttEQ==",
         "dependencies": {
-          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
+          "Microsoft.Bcl.AsyncInterfaces": "6.0.0"
         }
       },
-      "System.Memory": {
-        "type": "Transitive",
-        "resolved": "4.5.5",
-        "contentHash": "XIWiDvKPXaTveaB7HVganDlOCRoj03l+jrwNvcge/t8vhGYKvqV+dMv6G4SAX2NoNmN0wZfVPTAlFwZcZvVOUw=="
-      },
-      "System.Reflection.Emit": {
-        "type": "Transitive",
-        "resolved": "4.7.0",
-        "contentHash": "VR4kk8XLKebQ4MZuKuIni/7oh+QGFmZW3qORd1GvBq/8026OpW501SzT/oypwiQl4TvT8ErnReh/NzY9u+C6wQ=="
-      },
-      "System.Reflection.Emit.Lightweight": {
-        "type": "Transitive",
-        "resolved": "4.7.0",
-        "contentHash": "a4OLB4IITxAXJeV74MDx49Oq2+PsF6Sml54XAFv+2RyWwtDBcabzoxiiJRhdhx+gaohLh4hEGCLQyBozXoQPqA=="
-      },
       "System.Reflection.Metadata": {
         "type": "Transitive",
-        "resolved": "5.0.0",
+        "resolved": "7.0.0",
-        "contentHash": "5NecZgXktdGg34rh1OenY1rFNDCI8xSjFr+Z4OU4cU06AQHUdRnIIEeWENu3Wl4YowbzkymAIMvi3WyK9U53pQ=="
+        "contentHash": "MclTG61lsD9sYdpNz9xsKBzjsmsfCtcMZYXz/IUr2zlhaTaABonlr1ESeompTgM+Xk+IwtGYU7/voh3YWB/fWw==",
+        "dependencies": {
+          "System.Collections.Immutable": "7.0.0"
+        }
       },
       "System.Runtime.CompilerServices.Unsafe": {
         "type": "Transitive",
         "resolved": "6.0.0",
         "contentHash": "/iUeP3tq1S0XdNNoMz5C9twLSrM/TH+qElHkXWaPvuNOt+99G75NrV0OS2EqHx5wMN7popYjpc8oTjC1y16DLg=="
       },
+      "System.Security.Cryptography.Cng": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "jIMXsKn94T9JY7PvPq/tMfqa6GAaHpElRDpmG+SuL+D3+sTw2M8VhnibKnN8Tq+4JqbPJ/f+BwtLeDMEnzAvRg==",
+        "dependencies": {
+          "System.Formats.Asn1": "5.0.0"
+        }
+      },
+      "System.Security.Cryptography.Pkcs": {
+        "type": "Transitive",
+        "resolved": "5.0.0",
+        "contentHash": "9TPLGjBCGKmNvG8pjwPeuYy0SMVmGZRwlTZvyPHDbYv/DRkoeumJdfumaaDNQzVGMEmbWtg07zUpSW9q70IlDQ==",
+        "dependencies": {
+          "System.Formats.Asn1": "5.0.0",
+          "System.Security.Cryptography.Cng": "5.0.0"
+        }
+      },
+      "System.Security.Cryptography.ProtectedData": {
+        "type": "Transitive",
+        "resolved": "4.4.0",
+        "contentHash": "cJV7ScGW7EhatRsjehfvvYVBvtiSMKgN8bOVI0bQhnF5bU7vnHVIsH49Kva7i7GWaWYvmEzkYVk1TC+gZYBEog=="
+      },
       "System.Text.Encoding.CodePages": {
         "type": "Transitive",
-        "resolved": "6.0.0",
+        "resolved": "7.0.0",
-        "contentHash": "ZFCILZuOvtKPauZ/j/swhvw68ZRi9ATCfvGbk1QfydmcXBkIWecWKn/250UH7rahZ5OoDBaiAudJtPvLwzw85A==",
+        "contentHash": "LSyCblMpvOe0N3E+8e0skHcrIhgV2huaNcjUUEa8hRtgEAm36aGkRoC8Jxlb6Ra6GSfF29ftduPNywin8XolzQ=="
-        "dependencies": {
-          "System.Runtime.CompilerServices.Unsafe": "6.0.0"
-        }
       },
       "System.Text.Json": {
         "type": "Transitive",
-        "resolved": "5.0.1",
+        "resolved": "5.0.2",
-        "contentHash": "/UM3UK1dXKl8Ybysg/21gM4S8DJgkR+yLU8JwqCVbuNqQNImelntgYFAN5QxR8sJJ1kMx//hOUdf0lltosi8cQ=="
+        "contentHash": "I47dVIGiV6SfAyppphxqupertT/5oZkYLDCX6vC3HpOI4ZLjyoKAreUoem2ie6G0RbRuFrlqz/PcTQjfb2DOfQ=="
-      },
-      "System.Threading.Tasks.Extensions": {
-        "type": "Transitive",
-        "resolved": "4.5.4",
-        "contentHash": "zteT+G8xuGu6mS+mzDzYXbzS7rd3K6Fjb9RiZlYlJPam2/hU7JCBZBVEcywNuR+oZ1ncTvc/cq0faRr3P01OVg=="
       },
       "torch.api": {
         "type": "Project",
         "dependencies": {
           "JorgeSerrano.Json.JsonSnakeCaseNamingPolicy": "[0.9.0, )",
-          "NLog": "[5.1.0, )",
+          "Microsoft.Extensions.Configuration.Binder": "[7.0.4, )",
-          "SemanticVersioning": "[2.0.2, )"
+          "NLog": "[5.2.2, )",
+          "NuGet.Commands": "[6.6.1, )",
+          "NuGet.DependencyResolver.Core": "[6.6.1, )",
+          "SemanticVersioning": "[2.0.2, )",
+          "System.Linq.Async": "[6.0.1, )"
         }
       }
     }