Bump version

* Remove SkipMediaTypeDetection option, cleanup options window

* Shrink detection section in options

* always try to guess media type

.editorconfig

@@ -0,0 +1,4 @@
+[*.cs]
+
+# SYSLIB1045: Convert to 'GeneratedRegexAttribute'.
+dotnet_diagnostic.SYSLIB1045.severity = silent

.github/ISSUE_TEMPLATE/feature-request.md

@@ -0,0 +1,28 @@
+---
+name: Feature Request
+about: For when you know better than me what you want
+title: "[Request]"
+labels: enhancement
+assignees: mnadareski
+
+---
+
+**Before You Submit**
+
+- Remember to try the [latest WIP build](https://github.com/SabreTools/MPF/releases/tag/rolling) to see if the feature already exists.
+- Is it copy protection related? If so, report the issue [here](https://github.com/SabreTools/BinaryObjectScanner/issues) instead.
+- Check [previous issues](https://github.com/SabreTools/MPF/issues) to see if any of those are related to what you're about to ask for.
+
+If none of those apply, then continue...
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/informational.md

@@ -0,0 +1,22 @@
+---
+name: Info
+about: Something you need to tell me
+title: "[Info]"
+labels: question
+assignees: mnadareski
+
+---
+
+**Before You Submit**
+
+- Remember to try the [latest WIP build](https://github.com/SabreTools/MPF/releases/tag/rolling) to see if the feature already exists.
+- Is it copy protection related? If so, report the issue [here](https://github.com/SabreTools/BinaryObjectScanner/issues) instead.
+- Check [previous issues](https://github.com/SabreTools/MPF/issues) to see if any of those are related to what you're about to ask for.
+
+If none of those apply, then continue...
+
+**Is your information related to one of the dumping programs supported or something that isn't a bug in the code? Please describe.**
+A clear and concise description of what the information is. Ex. With the latest build of DumpingProgram, it [...]
+
+**Additional context**
+Add any other context or screenshots about the information here.

.github/ISSUE_TEMPLATE/issue-report.md

@@ -0,0 +1,48 @@
+---
+name: Issue Report
+about: Tell me what's wrong, seriously
+title: "[Problem]"
+labels: bug
+assignees: mnadareski
+
+---
+
+**Before You Submit**
+
+- Remember to try the [latest WIP build](https://github.com/SabreTools/MPF/releases/tag/rolling) to see if the issue has already been addressed.
+- Is it copy protection related? If so, report the issue [here](https://github.com/SabreTools/BinaryObjectScanner/issues) instead.
+- Check multiple discs to help narrow down the issue
+- Check the Options to see if changing any of those affects your issue.
+
+If all of those fail, then continue...
+
+**Version**
+What version are you using?
+
+- [ ] Stable release (version here)
+- [ ] WIP release (version here)
+
+**Build**
+What runtime version are you using?
+
+- [ ] .NET 9.0 running on (Operating System)
+
+**Describe the issue**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+
+1. Go to '...'
+2. Click on '....'
+3. Scroll down to '....'
+4. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.

.github/workflows/build_and_test.yml

@@ -0,0 +1,40 @@
+name: Build and Test
+
+on:
+  push:
+    branches: [ "master" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+    
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: |
+            6.0.x
+            8.0.x
+            9.0.x
+        
+    - name: Run tests
+      run: dotnet test
+      
+    - name: Run publish script
+      run: ./publish-nix.sh -dp
+
+    - name: Upload to rolling
+      uses: ncipollo/release-action@v1.14.0
+      with:
+        allowUpdates: True
+        artifacts: "*.nupkg,*.snupkg,*.zip"
+        body: 'Last built commit: ${{ github.sha }}'
+        name: 'Rolling Release'
+        prerelease: True
+        replacesArtifacts: True
+        tag: "rolling"
+        updateOnlyUnreleased: True

.github/workflows/check_pr.yml

@@ -0,0 +1,26 @@
+name: Build PR
+
+on: [pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v4
+      with:
+        dotnet-version: |
+            6.0.x
+            8.0.x
+            9.0.x
+
+    - name: Restore dependencies
+      run: dotnet restore
+
+    - name: Build
+      run: dotnet build
+
+    - name: Test
+      run: dotnet test

.gitignore

@@ -68,7 +68,6 @@ artifacts/
 *.tlh
 *.tmp
 *.tmp_proj
-*.log
 *.vspscc
 *.vssscc
 .builds

.vscode/launch.json

@@ -0,0 +1,42 @@
+{
+   // Use IntelliSense to find out which attributes exist for C# debugging
+   // Use hover for the description of the existing attributes
+   // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+   "version": "0.2.0",
+   "configurations": [
+        {
+            "name": ".NET Core Launch (Check)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/MPF.Check/bin/Debug/net9.0/MPF.Check.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/MPF.Check",
+            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+            "console": "internalConsole",
+            "stopAtEntry": false,
+            "justMyCode": false
+        },
+        {
+            "name": ".NET Core Launch (CLI)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/MPF.CLI/bin/Debug/net9.0/MPF.CLI.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/MPF.CLI",
+            // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
+            "console": "internalConsole",
+            "stopAtEntry": false,
+            "justMyCode": false
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach",
+            "processId": "${command:pickProcess}"
+        }
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "omnisharp.projectLoadTimeout": 480
+}

.vscode/tasks.json

@@ -0,0 +1,28 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/MPF.sln",
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "${workspaceFolder}/MPF/MPF.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

App.config

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<configuration>
-    <configSections>
-        <sectionGroup name="userSettings" type="System.Configuration.UserSettingsGroup, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" >
-            <section name="DICUI.Properties.Settings" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false" />
-        </sectionGroup>
-    </configSections>
-    <startup> 
-        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.1" />
-    </startup>
-    <userSettings>
-        <DICUI.Properties.Settings>
-            <setting name="
-                     " serializeAs="String">
-                <value>Release_ANSI\\DiscImageCreator.exe</value>
-            </setting>
-        </DICUI.Properties.Settings>
-    </userSettings>
-</configuration>

App.xaml

@@ -1,9 +0,0 @@
-<Application x:Class="DICUI.App"
-             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:local="clr-namespace:DICUI"
-             StartupUri="MainWindow.xaml">
-    <Application.Resources>
-         
-    </Application.Resources>
-</Application>

App.xaml.cs

@@ -1,17 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Configuration;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
-using System.Windows;
-
-namespace DICUI
-{
-    /// <summary>
-    /// Interaction logic for App.xaml
-    /// </summary>
-    public partial class App : Application
-    {
-    }
-}

Constants.cs

@@ -1,101 +0,0 @@
-namespace DICUI
-{
-    public static class UIElements
-    {
-        public const string StartDumping = "Start Dumping";
-        public const string StopDumping = "Stop Dumping";
-    }
-
-    public static class DICCommands
-    {
-        // Commands
-
-        public const string CompactDiscCommand = "cd";
-        public const string DataCommand = "data";
-        public const string AudioCommand = "audio";
-        public const string GDROMCommand = "gd";
-        public const string GDROMSwapCommand = "swap";
-        public const string DVDCommand = "dvd";
-        public const string BDCommand = "bd";
-        public const string FloppyCommand = "fd";
-        public const string StopCommand = "stop";
-        public const string StartCommand = "start";
-        public const string EjectCommand = "eject";
-        public const string CloseCommand = "close";
-        public const string ResetCommand = "reset";
-        public const string SubCommand = "sub";
-        public const string MDSCommand = "mds";
-        public const string DriveSpeedCommand = "ls"; // Unlisted in help text
-
-        // DIC Flags
-
-        public const string ForceUnitAccessFlag = "/f";
-        public const string DisableBeepFlag = "/q";
-        public const string CDAddOffsetFlag = "/a";
-        public const string CDBEOpcodeFlag = "/be";
-        public const string CDD8OpcodeFlag = "/d8";
-        public const string CDC2OpcodeFlag = "/c2";
-        public const string CDMCNFlag = "/m";
-        public const string CDAMSFFlag = "/p";
-        public const string CDReverseFlag = "/r";
-        public const string CDMultiSessionFlag = "/ms";
-        public const string CDScanFileProtectFlag = "/sf";
-        public const string CDScanSectorProtectFlag = "/ss";
-        public const string CDScanAnitModFlag = "/am";
-        public const string CDNoFixSubPFlag = "/np";
-        public const string CDNoFixSubQFlag = "/nq";
-        public const string CDNoFixSubRtoWFlag = "/nr";
-        public const string CDNoFixSubQLibCryptFlag = "/nl";
-        public const string CDNoFixSubQSecuROMFlag = "/ns";
-        public const string CDSubchannelReadLevelFlag = "/s";
-        public const string DVDCMIFlag = "/c";
-        public const string DVDRawFlag = "/raw";
-    }
-
-    public static class Template
-    {
-        // Manual information
-
-        public const string TitleField = "Title";
-        public const string DiscNumberField = "Disc Number / Letter";
-        public const string DiscTitleField = "Disc Title";
-        public const string CategoryField = "Category";
-        public const string RegionField = "Region";
-        public const string LanguagesField = "Languages";
-        public const string DiscSerialField = "Disc Serial";
-        public const string BarcodeField = "Barcode";
-        public const string ISBNField = "ISBN";
-        public const string CommentsField = "Comments";
-        public const string ContentsField = "Contents";
-        public const string VersionField = "Version";
-        public const string EditionField = "Edition/Release";
-        public const string CopyProtectionField = "Copy Protection";
-        public const string MasteringRingField = "Mastering Ring";
-        public const string MasteringSIDField = "Mastering SID Code";
-        public const string MouldSIDField = "Mould SID Code";
-        public const string AdditionalMouldField = "Additional Mould";
-        public const string ToolstampField = "Toolstamp or Mastering Code";
-
-        // Automatic Information
-
-        public const string PVDField = "Primary Volume Descriptor (PVD)";
-        public const string DATField = "DAT";
-        public const string ErrorCountField = "Error Count";
-        public const string CuesheetField = "Cuesheet";
-        public const string WriteOffsetField = "WriteOffset";
-        public const string LayerbreakField = "Layerbreak";
-        public const string PlaystationEXEDateField = "EXE Date"; // TODO: Not automatic yet
-        public const string PlayStationEDCField = "EDC"; // TODO: Not automatic yet
-        public const string PlayStationAntiModchipField = "Anti-modchip"; // TODO: Not automatic yet
-        public const string PlayStationLibCryptField = "LibCrypt"; // TODO: Not automatic yet
-        public const string SaturnHeaderField = "Header"; // TODO: Not automatic yet
-        public const string SaturnBuildDateField = "Build Date"; // TODO: Not automatic yet
-
-        // Default values
-
-        public const string RequiredValue = "(REQUIRED)";
-        public const string RequiredIfExistsValue = "(REQUIRED, IF EXISTS)";
-        public const string OptionalValue = "(OPTIONAL)";
-        public const string YesNoValue = "Yes/No";
-    }
-}

DICUI.csproj

@@ -1,139 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{7B1B75EB-8940-466F-BD51-76471A57F9BE}</ProjectGuid>
-    <OutputType>WinExe</OutputType>
-    <RootNamespace>DICUI</RootNamespace>
-    <AssemblyName>DICUI</AssemblyName>
-    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <ProjectTypeGuids>{60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
-    <WarningLevel>4</WarningLevel>
-    <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
-    <IsWebBootstrapper>false</IsWebBootstrapper>
-    <PublishUrl>C:\Users\admin\Desktop\</PublishUrl>
-    <Install>true</Install>
-    <InstallFrom>Disk</InstallFrom>
-    <UpdateEnabled>false</UpdateEnabled>
-    <UpdateMode>Foreground</UpdateMode>
-    <UpdateInterval>7</UpdateInterval>
-    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
-    <UpdatePeriodically>false</UpdatePeriodically>
-    <UpdateRequired>false</UpdateRequired>
-    <MapFileExtensions>true</MapFileExtensions>
-    <ApplicationRevision>1</ApplicationRevision>
-    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
-    <UseApplicationTrust>false</UseApplicationTrust>
-    <PublishWizardCompleted>true</PublishWizardCompleted>
-    <BootstrapperEnabled>true</BootstrapperEnabled>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <PlatformTarget>x86</PlatformTarget>
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-  </PropertyGroup>
-  <PropertyGroup>
-    <ApplicationIcon>Icon.ico</ApplicationIcon>
-  </PropertyGroup>
-  <PropertyGroup>
-    <ManifestCertificateThumbprint>654CEE5FEAF46C8C1C369D7ED34DA157828A8D2F</ManifestCertificateThumbprint>
-  </PropertyGroup>
-  <PropertyGroup>
-    <ManifestKeyFile>WpfApp1_TemporaryKey.pfx</ManifestKeyFile>
-  </PropertyGroup>
-  <PropertyGroup>
-    <GenerateManifests>true</GenerateManifests>
-  </PropertyGroup>
-  <PropertyGroup>
-    <SignManifests>false</SignManifests>
-  </PropertyGroup>
-  <PropertyGroup />
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Data" />
-    <Reference Include="System.Windows.Forms" />
-    <Reference Include="System.Xml" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Core" />
-    <Reference Include="System.Xml.Linq" />
-    <Reference Include="System.Data.DataSetExtensions" />
-    <Reference Include="System.Net.Http" />
-    <Reference Include="System.Xaml">
-      <RequiredTargetFramework>4.0</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="WindowsBase" />
-    <Reference Include="PresentationCore" />
-    <Reference Include="PresentationFramework" />
-  </ItemGroup>
-  <ItemGroup>
-    <ApplicationDefinition Include="App.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </ApplicationDefinition>
-    <Compile Include="Constants.cs" />
-    <Compile Include="Utilities.cs" />
-    <Page Include="MainWindow.xaml">
-      <Generator>MSBuild:Compile</Generator>
-      <SubType>Designer</SubType>
-    </Page>
-    <Compile Include="App.xaml.cs">
-      <DependentUpon>App.xaml</DependentUpon>
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Enumerations.cs" />
-    <Compile Include="MainWindow.xaml.cs">
-      <DependentUpon>MainWindow.xaml</DependentUpon>
-      <SubType>Code</SubType>
-    </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Properties\AssemblyInfo.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Properties\Resources.Designer.cs">
-      <AutoGen>True</AutoGen>
-      <DesignTime>True</DesignTime>
-      <DependentUpon>Resources.resx</DependentUpon>
-    </Compile>
-    <EmbeddedResource Include="Properties\Resources.resx">
-      <Generator>ResXFileCodeGenerator</Generator>
-      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
-    </EmbeddedResource>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="App.config" />
-  </ItemGroup>
-  <ItemGroup>
-    <BootstrapperPackage Include=".NETFramework,Version=v4.6.1">
-      <Visible>False</Visible>
-      <ProductName>Microsoft .NET Framework 4.6.1 %28x86 and x64%29</ProductName>
-      <Install>true</Install>
-    </BootstrapperPackage>
-    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
-      <Visible>False</Visible>
-      <ProductName>.NET Framework 3.5 SP1</ProductName>
-      <Install>false</Install>
-    </BootstrapperPackage>
-  </ItemGroup>
-  <ItemGroup>
-    <Resource Include="Icon.ico" />
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-</Project>

DICUI.sln

@@ -1,25 +0,0 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.27130.2036
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DICUI", "DICUI.csproj", "{7B1B75EB-8940-466F-BD51-76471A57F9BE}"
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{7B1B75EB-8940-466F-BD51-76471A57F9BE}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {73C62E6A-6584-4D93-83B5-ECB1FBDB469B}
-	EndGlobalSection
-EndGlobal

Enumerations.cs

@@ -1,107 +0,0 @@
-namespace DICUI
-{
-    /// <summary>
-    /// Known disc types
-    /// </summary>
-    public enum DiscType
-    {
-        NONE = 0,
-        CD,
-        DVD5,
-        DVD9,
-        GDROM,
-        HDDVD,
-        BD25,
-        BD50,
-
-        // Special Formats
-        GameCubeGameDisc,
-        UMD,
-        
-        // Keeping this separate since it's currently unsupported in the UI
-        Floppy = 99,
-    }
-
-    /// <summary>
-    /// Known systems
-    /// </summary>
-    /// <remarks>Ensure that Utilities methods are updated as well</remarks>
-    public enum KnownSystem
-    {
-        NONE = 0,
-
-        #region Consoles
-
-        BandaiPlaydiaQuickInteractiveSystem,
-        BandaiApplePippin,
-        CommodoreAmigaCD32,
-        CommodoreAmigaCDTV,
-        MattelHyperscan,
-        MicrosoftXBOX,
-        MicrosoftXBOX360,
-        MicrosoftXBOXOne,
-        NECPCEngineTurboGrafxCD,
-        NECPCFX,
-        NintendoGameCube,
-        NintendoWii,
-        NintendoWiiU,
-        Panasonic3DOInteractiveMultiplayer,
-        PhilipsCDi,
-        SegaCDMegaCD,
-        SegaDreamcast,
-        SegaSaturn,
-        SNKNeoGeoCD,
-        SonyPlayStation,
-        SonyPlayStation2,
-        SonyPlayStation3,
-        SonyPlayStation4,
-        SonyPlayStationPortable,
-        VMLabsNuon,
-        VTechVFlashVSmilePro,
-        ZAPiTGamesGameWaveFamilyEntertainmentSystem,
-
-        #endregion
-
-        #region Computers
-
-        AcornArchimedes,
-        AppleMacintosh,
-        CommodoreAmigaCD,
-        FujitsuFMTowns,
-        IBMPCCompatible,
-        NECPC88,
-        NECPC98,
-        SharpX68000,
-
-        #endregion
-
-        #region Arcade
-
-        NamcoSegaNintendoTriforce,
-        NamcoSystem246,
-        SegaChihiro,
-        SegaLindbergh,
-        SegaNaomi,
-        SegaNaomi2,
-        TABAustriaQuizard,
-        TandyMemorexVisualInformationSystem,
-
-        #endregion
-
-        #region Other
-
-        AudioCD,
-        BDVideo,
-        DVDVideo,
-        EnhancedCD,
-        PalmOS,
-        PhilipsCDiDigitalVideo,
-        PhotoCD,
-        PlayStationGameSharkUpdates,
-        TaoiKTV,
-        TomyKissSite,
-        VideoCD,
-
-        #endregion
-    }
-}

LICENSE

@@ -652,7 +652,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    DICUI  Copyright (C) 2018  ReignStumble
+    MPF  Copyright (C) 2018  ReignStumble
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.

MPF.CLI/MPF.CLI.csproj

@@ -0,0 +1,49 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <!-- Assembly Properties -->
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
+        <OutputType>Exe</OutputType>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <LangVersion>latest</LangVersion>
+        <NoWarn>NU1902;NU1903</NoWarn>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <VersionPrefix>3.4.1</VersionPrefix>
+
+        <!-- Package Properties -->
+        <Title>MPF CLI</Title>
+        <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+        <Description>CLI frontend for various dumping programs</Description>
+        <Copyright>Copyright (c) Matt Nadareski 2019-2025</Copyright>
+        <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+    </PropertyGroup>
+
+    <!-- Support All Frameworks -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net4`))">
+        <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`netcoreapp`)) OR $(TargetFramework.StartsWith(`net5`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`)) OR $(TargetFramework.StartsWith(`net9`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+        <TargetFrameworks>net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\MPF.Frontend\MPF.Frontend.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="SabreTools.RedumpLib" Version="1.7.4" />
+    </ItemGroup>
+
+</Project>

MPF.CLI/Program.cs

@@ -0,0 +1,544 @@
+using System;
+using System.IO;
+#if NET40
+using System.Threading.Tasks;
+#endif
+using MPF.Frontend;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Web;
+
+namespace MPF.CLI
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            // Load options from the config file
+            var options = OptionsLoader.LoadFromConfig();
+            if (options.FirstRun)
+            {
+                // Application paths
+                options.AaruPath = "FILL ME IN";
+                options.DiscImageCreatorPath = "FILL ME IN";
+                options.RedumperPath = "FILL ME IN";
+                options.InternalProgram = InternalProgram.NONE;
+
+                // Reset first run
+                options.FirstRun = false;
+                OptionsLoader.SaveToConfig(options);
+
+                // Display non-error message
+                DisplayHelp("First-run detected! Please fill out config.json and run again.");
+                return;
+            }
+
+            // Try processing the standalone arguments
+            bool? standaloneProcessed = OptionsLoader.ProcessStandaloneArguments(args);
+            if (standaloneProcessed != false)
+            {
+                if (standaloneProcessed == null)
+                    DisplayHelp();
+                return;
+            }
+
+            // Setup common outputs
+            CommandOptions opts;
+            RedumpSystem? knownSystem;
+
+            // Use interactive mode
+            if (args.Length > 0 && (args[0] == "-i" || args[0] == "--interactive"))
+            {
+                opts = InteractiveMode(options, out knownSystem);
+            }
+
+            // Use normal commandline parameters
+            else
+            {
+                // Try processing the common arguments
+                bool success = OptionsLoader.ProcessCommonArguments(args, out knownSystem, out var error);
+                if (!success)
+                {
+                    DisplayHelp(error);
+                    return;
+                }
+
+                // Validate the supplied credentials
+                if (options.RetrieveMatchInformation
+                    && !string.IsNullOrEmpty(options.RedumpUsername)
+                    && !string.IsNullOrEmpty(options.RedumpPassword))
+                {
+                    bool? validated = RedumpClient.ValidateCredentials(options.RedumpUsername!, options.RedumpPassword!).GetAwaiter().GetResult();
+                    string message = validated switch
+                    {
+                        true => "Redump username and password accepted!",
+                        false => "Redump username and password denied!",
+                        null => "An error occurred validating your credentials!",
+                    };
+
+                    Console.WriteLine(message);
+                }
+
+                // Process any custom parameters
+                int startIndex = 2;
+                opts = LoadFromArguments(args, options, ref startIndex);
+            }
+
+            // Validate the internal program
+            switch (options.InternalProgram)
+            {
+                case InternalProgram.Aaru:
+                    if (!File.Exists(options.AaruPath))
+                    {
+                        DisplayHelp("A path needs to be supplied in config.json for Aaru, exiting...");
+                        return;
+                    }
+                    break;
+
+                case InternalProgram.DiscImageCreator:
+                    if (!File.Exists(options.DiscImageCreatorPath))
+                    {
+                        DisplayHelp("A path needs to be supplied in config.json for DIC, exiting...");
+                        return;
+                    }
+                    break;
+
+                case InternalProgram.Redumper:
+                    if (!File.Exists(options.RedumperPath))
+                    {
+                        DisplayHelp("A path needs to be supplied in config.json for Redumper, exiting...");
+                        return;
+                    }
+                    break;
+
+                default:
+                    DisplayHelp($"{options.InternalProgram} is not a supported dumping program, exiting...");
+                    break;
+            }
+
+            // Ensure we have the values we need
+            if (opts.CustomParams == null && (opts.DevicePath == null || opts.FilePath == null))
+            {
+                DisplayHelp("Both a device path and file path need to be supplied, exiting...");
+                return;
+            }
+            if (options.InternalProgram == InternalProgram.DiscImageCreator
+                && opts.CustomParams == null
+                && (opts.MediaType == null || opts.MediaType == MediaType.NONE))
+            {
+                DisplayHelp("Media type is required for DiscImageCreator, exiting...");
+                return;
+            }
+
+            // Normalize the file path
+                if (opts.FilePath != null)
+                    opts.FilePath = FrontendTool.NormalizeOutputPaths(opts.FilePath, getFullPath: true);
+
+            // Get the speed from the options
+            int speed = opts.DriveSpeed ?? FrontendTool.GetDefaultSpeedForMediaType(opts.MediaType, options);
+
+            // Populate an environment
+            var drive = Drive.Create(null, opts.DevicePath ?? string.Empty);
+            var env = new DumpEnvironment(options,
+                opts.FilePath,
+                drive,
+                knownSystem,
+                options.InternalProgram);
+            env.SetExecutionContext(opts.MediaType, null);
+            env.SetProcessor();
+
+            // Process the parameters
+            string? paramStr = opts.CustomParams ?? env.GetFullParameters(opts.MediaType, speed);
+            if (string.IsNullOrEmpty(paramStr))
+            {
+                DisplayHelp("No valid environment could be created, exiting...");
+                return;
+            }
+
+            env.SetExecutionContext(opts.MediaType, paramStr);
+
+            // Invoke the dumping program
+            Console.WriteLine($"Invoking {options.InternalProgram} using '{paramStr}'");
+            var dumpResult = env.Run(opts.MediaType).GetAwaiter().GetResult();
+            Console.WriteLine(dumpResult.Message);
+            if (!dumpResult)
+                return;
+
+            // If it was not a dumping command
+            if (!env.IsDumpingCommand())
+            {
+                Console.WriteLine("Execution not recognized as dumping command, skipping processing...");
+                return;
+            }
+
+            // If we have a mounted path, replace the environment
+            if (opts.MountedPath != null && Directory.Exists(opts.MountedPath))
+            {
+                drive = Drive.Create(null, opts.MountedPath);
+                env = new DumpEnvironment(options,
+                    opts.FilePath,
+                    drive,
+                    knownSystem,
+                    internalProgram: null);
+                env.SetExecutionContext(opts.MediaType, null);
+                env.SetProcessor();
+            }
+
+            // Finally, attempt to do the output dance
+            var verifyResult = env.VerifyAndSaveDumpOutput()
+                .ConfigureAwait(false).GetAwaiter().GetResult();
+            Console.WriteLine(verifyResult.Message);
+        }
+
+        /// <summary>
+        /// Display help for MPF.CLI
+        /// </summary>
+        /// <param name="error">Error string to prefix the help text with</param>
+        private static void DisplayHelp(string? error = null)
+        {
+            if (error != null)
+                Console.WriteLine(error);
+
+            Console.WriteLine("Usage:");
+            Console.WriteLine("MPF.CLI <system> [options]");
+            Console.WriteLine();
+            Console.WriteLine("Standalone Options:");
+            Console.WriteLine("-h, -?, --help          Show this help text");
+            Console.WriteLine("--version               Print the program version");
+            Console.WriteLine("-lc, --listcodes        List supported comment/content site codes");
+            Console.WriteLine("-lm, --listmedia        List supported media types");
+            Console.WriteLine("-ls, --listsystems      List supported system types");
+            Console.WriteLine("-lp, --listprograms     List supported dumping program outputs");
+            Console.WriteLine("-i, --interactive       Enable interactive mode");
+            Console.WriteLine();
+
+            Console.WriteLine("CLI Options:");
+            Console.WriteLine("-u, --use <program>            Override configured dumping program name");
+            Console.WriteLine("-t, --mediatype <mediatype>    Set media type for dumping (Required for DIC)");
+            Console.WriteLine("-d, --device <devicepath>      Physical drive path (Required if no custom parameters set)");
+            Console.WriteLine("-m, --mounted <dirpath>        Mounted filesystem path for additional checks");
+            Console.WriteLine("-f, --file \"<filepath>\"        Output file path (Required if no custom parameters set)");
+            Console.WriteLine("-s, --speed <speed>            Override default dumping speed");
+            Console.WriteLine("-c, --custom \"<params>\"        Custom parameters to use");
+            Console.WriteLine();
+
+            Console.WriteLine("Dumping program paths and other settings can be found in the config.json file");
+            Console.WriteLine("generated next to the program by default. Ensure that all settings are to user");
+            Console.WriteLine("preference before running MPF.CLI.");
+            Console.WriteLine();
+
+            Console.WriteLine("Custom dumping parameters, if used, will fully replace the default parameters.");
+            Console.WriteLine("All dumping parameters need to be supplied if doing this.");
+            Console.WriteLine("Otherwise, both a drive path and output file path are required.");
+            Console.WriteLine();
+
+            Console.WriteLine("Mounted filesystem path is only recommended on OSes that require block");
+            Console.WriteLine("device dumping, usually Linux and macOS.");
+            Console.WriteLine();
+        }
+
+        /// <summary>
+        /// Enable interactive mode for entering information
+        /// </summary>
+        private static CommandOptions InteractiveMode(Options options, out RedumpSystem? system)
+        {
+            // Create return values
+            var opts = new CommandOptions
+            {
+                MediaType = MediaType.NONE,
+                FilePath = Path.Combine(options.DefaultOutputPath ?? "ISO", "track.bin"),
+            };
+            system = options.DefaultSystem;
+
+            // Create state values
+            string? result = string.Empty;
+
+        root:
+            Console.Clear();
+            Console.WriteLine("MPF.CLI Interactive Mode - Main Menu");
+            Console.WriteLine("-------------------------");
+            Console.WriteLine();
+            Console.WriteLine($"1) Set system (Currently '{system}')");
+            Console.WriteLine($"2) Set dumping program (Currently '{options.InternalProgram}')");
+            Console.WriteLine($"3) Set media type (Currently '{opts.MediaType}')");
+            Console.WriteLine($"4) Set device path (Currently '{opts.DevicePath}')");
+            Console.WriteLine($"5) Set mounted path (Currently '{opts.MountedPath}')");
+            Console.WriteLine($"6) Set file path (Currently '{opts.FilePath}')");
+            Console.WriteLine($"7) Set override speed (Currently '{opts.DriveSpeed}')");
+            Console.WriteLine($"8) Set custom parameters (Currently '{opts.CustomParams}')");
+            Console.WriteLine();
+            Console.WriteLine($"Q) Exit the program");
+            Console.WriteLine($"X) Start dumping");
+            Console.Write("> ");
+
+            result = Console.ReadLine();
+            switch (result)
+            {
+                case "1":
+                    goto system;
+                case "2":
+                    goto dumpingProgram;
+                case "3":
+                    goto mediaType;
+                case "4":
+                    goto devicePath;
+                case "5":
+                    goto mountedPath;
+                case "6":
+                    goto filePath;
+                case "7":
+                    goto overrideSpeed;
+                case "8":
+                    goto customParams;
+
+                case "q":
+                case "Q":
+                    Environment.Exit(0);
+                    break;
+                case "x":
+                case "X":
+                    Console.Clear();
+                    goto exit;
+                case "z":
+                case "Z":
+                    Console.WriteLine("It is pitch black. You are likely to be eaten by a grue.");
+                    Console.Write("> ");
+                    Console.ReadLine();
+                    goto root;
+                default:
+                    Console.WriteLine($"Invalid selection: {result}");
+                    Console.ReadLine();
+                    goto root;
+            }
+
+        system:
+            Console.WriteLine();
+            Console.WriteLine("Input the system and press Enter:");
+            Console.Write("> ");
+            result = Console.ReadLine();
+            system = Extensions.ToRedumpSystem(result);
+            goto root;
+
+        dumpingProgram:
+            Console.WriteLine();
+            Console.WriteLine("Input the dumping program and press Enter:");
+            Console.Write("> ");
+            result = Console.ReadLine();
+            options.InternalProgram = result.ToInternalProgram();
+            goto root;
+
+        mediaType:
+            Console.WriteLine();
+            Console.WriteLine("Input the media type and press Enter:");
+            Console.Write("> ");
+            result = Console.ReadLine();
+            opts.MediaType = OptionsLoader.ToMediaType(result);
+            goto root;
+
+        devicePath:
+            Console.WriteLine();
+            Console.WriteLine("Input the device path and press Enter:");
+            Console.Write("> ");
+            opts.DevicePath = Console.ReadLine();
+            goto root;
+
+        mountedPath:
+            Console.WriteLine();
+            Console.WriteLine("Input the mounted path and press Enter:");
+            Console.Write("> ");
+            opts.MountedPath = Console.ReadLine();
+            goto root;
+
+        filePath:
+            Console.WriteLine();
+            Console.WriteLine("Input the file path and press Enter:");
+            Console.Write("> ");
+
+            result = Console.ReadLine();
+            if (!string.IsNullOrEmpty(result))
+                result = Path.GetFullPath(result!);
+
+            opts.FilePath = result;
+            goto root;
+
+        overrideSpeed:
+            Console.WriteLine();
+            Console.WriteLine("Input the override speed and press Enter:");
+            Console.Write("> ");
+
+            result = Console.ReadLine();
+            if (!int.TryParse(result, out int speed))
+                speed = -1;
+
+            opts.DriveSpeed = speed;
+            goto root;
+
+        customParams:
+            Console.WriteLine();
+            Console.WriteLine("Input the custom parameters and press Enter:");
+            Console.Write("> ");
+            opts.CustomParams = Console.ReadLine();
+            goto root;
+
+        exit:
+            return opts;
+        }
+
+        /// <summary>
+        /// Load the current set of options from application arguments
+        /// </summary>
+        private static CommandOptions LoadFromArguments(string[] args, Options options, ref int startIndex)
+        {
+            // Create return values
+            var opts = new CommandOptions();
+
+            // If we have no arguments, just return
+            if (args == null || args.Length == 0)
+            {
+                startIndex = 0;
+                return opts;
+            }
+
+            // If we have an invalid start index, just return
+            if (startIndex < 0 || startIndex >= args.Length)
+                return opts;
+
+            // Loop through the arguments and parse out values
+            for (; startIndex < args.Length; startIndex++)
+            {
+                // Use specific program
+                if (args[startIndex].StartsWith("-u=") || args[startIndex].StartsWith("--use="))
+                {
+                    string internalProgram = args[startIndex].Split('=')[1];
+                    options.InternalProgram = internalProgram.ToInternalProgram();
+                }
+                else if (args[startIndex] == "-u" || args[startIndex] == "--use")
+                {
+                    string internalProgram = args[startIndex + 1];
+                    options.InternalProgram = internalProgram.ToInternalProgram();
+                    startIndex++;
+                }
+
+                // Use a device path
+                else if (args[startIndex].StartsWith("-t=") || args[startIndex].StartsWith("--mediatype="))
+                {
+                    opts.MediaType = OptionsLoader.ToMediaType(args[startIndex].Split('=')[1].Trim('"'));
+                }
+                else if (args[startIndex] == "-t" || args[startIndex] == "--mediatype")
+                {
+                    opts.MediaType = OptionsLoader.ToMediaType(args[startIndex + 1].Trim('"'));
+                    startIndex++;
+                }
+
+                // Use a device path
+                else if (args[startIndex].StartsWith("-d=") || args[startIndex].StartsWith("--device="))
+                {
+                    opts.DevicePath = args[startIndex].Split('=')[1].Trim('"');
+                }
+                else if (args[startIndex] == "-d" || args[startIndex] == "--device")
+                {
+                    opts.DevicePath = args[startIndex + 1].Trim('"');
+                    startIndex++;
+                }
+
+                // Use a mounted path for physical checks
+                else if (args[startIndex].StartsWith("-m=") || args[startIndex].StartsWith("--mounted="))
+                {
+                    opts.MountedPath = args[startIndex].Split('=')[1];
+                }
+                else if (args[startIndex] == "-m" || args[startIndex] == "--mounted")
+                {
+                    opts.MountedPath = args[startIndex + 1];
+                    startIndex++;
+                }
+
+                // Use a file path
+                else if (args[startIndex].StartsWith("-f=") || args[startIndex].StartsWith("--file="))
+                {
+                    opts.FilePath = args[startIndex].Split('=')[1].Trim('"');
+                }
+                else if (args[startIndex] == "-f" || args[startIndex] == "--file")
+                {
+                    opts.FilePath = args[startIndex + 1].Trim('"');
+                    startIndex++;
+                }
+
+                // Set an override speed
+                else if (args[startIndex].StartsWith("-s=") || args[startIndex].StartsWith("--speed="))
+                {
+                    if (!int.TryParse(args[startIndex].Split('=')[1].Trim('"'), out int speed))
+                        speed = -1;
+
+                    opts.DriveSpeed = speed;
+                }
+                else if (args[startIndex] == "-s" || args[startIndex] == "--speed")
+                {
+                    if (!int.TryParse(args[startIndex + 1].Trim('"'), out int speed))
+                        speed = -1;
+
+                    opts.DriveSpeed = speed;
+                    startIndex++;
+                }
+
+                // Use a custom parameters
+                else if (args[startIndex].StartsWith("-c=") || args[startIndex].StartsWith("--custom="))
+                {
+                    opts.CustomParams = args[startIndex].Split('=')[1].Trim('"');
+                }
+                else if (args[startIndex] == "-c" || args[startIndex] == "--custom")
+                {
+                    opts.CustomParams = args[startIndex + 1].Trim('"');
+                    startIndex++;
+                }
+
+                // Default, we fall out
+                else
+                {
+                    break;
+                }
+            }
+
+            return opts;
+        }
+
+        /// <summary>
+        /// Represents commandline options
+        /// </summary>
+        private class CommandOptions
+        {
+            /// <summary>
+            /// Media type to dump
+            /// </summary>
+            /// <remarks>Required for DIC and if custom parameters not set</remarks>
+            public MediaType? MediaType { get; set; } = null;
+
+            /// <summary>
+            /// Path to the device to dump
+            /// </summary>
+            /// <remarks>Required if custom parameters are not set</remarks>
+            public string? DevicePath { get; set; } = null;
+
+            /// <summary>
+            /// Path to the mounted filesystem to check
+            /// </summary>
+            /// <remarks>Should only be used when the device path is not readable</remarks>
+            public string? MountedPath { get; set; } = null;
+
+            /// <summary>
+            /// Path to the output file
+            /// </summary>
+            /// <remarks>Required if custom parameters are not set</remarks>
+            public string? FilePath { get; set; } = null;
+
+            /// <summary>
+            /// Override drive speed
+            /// </summary>
+            public int? DriveSpeed { get; set; } = null;
+
+            /// <summary>
+            /// Custom parameters for dumping
+            /// </summary>
+            public string? CustomParams { get; set; } = null;
+        }
+    }
+}

MPF.Check/MPF.Check.csproj

@@ -0,0 +1,49 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <!-- Assembly Properties -->
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
+        <OutputType>Exe</OutputType>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <LangVersion>latest</LangVersion>
+        <NoWarn>NU1902;NU1903</NoWarn>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <VersionPrefix>3.4.1</VersionPrefix>
+
+        <!-- Package Properties -->
+        <Title>MPF Check</Title>
+        <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+        <Description>Validator for various dumping programs</Description>
+        <Copyright>Copyright (c) Matt Nadareski 2019-2025</Copyright>
+        <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+    </PropertyGroup>
+
+    <!-- Support All Frameworks -->
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net4`))">
+        <RuntimeIdentifiers>win-x86;win-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`netcoreapp`)) OR $(TargetFramework.StartsWith(`net5`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`)) OR $(TargetFramework.StartsWith(`net9`))">
+        <RuntimeIdentifiers>win-x86;win-x64;win-arm64;linux-x64;linux-arm64;osx-x64;osx-arm64</RuntimeIdentifiers>
+    </PropertyGroup>
+    <PropertyGroup Condition="$(RuntimeIdentifier.StartsWith(`osx-arm`))">
+        <TargetFrameworks>net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\MPF.Frontend\MPF.Frontend.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="SabreTools.RedumpLib" Version="1.7.4" />
+    </ItemGroup>
+
+</Project>

MPF.Check/Program.cs

@@ -0,0 +1,561 @@
+using System;
+using System.IO;
+#if NET40
+using System.Threading.Tasks;
+#endif
+using MPF.Frontend;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Web;
+
+namespace MPF.Check
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            // Create a default options object
+            var options = new Options()
+            {
+                // Internal Program
+                InternalProgram = InternalProgram.NONE,
+
+                // Extra Dumping Options
+                ScanForProtection = false,
+                AddPlaceholders = true,
+                PullAllInformation = false,
+                AddFilenameSuffix = false,
+                OutputSubmissionJSON = false,
+                IncludeArtifacts = false,
+                CompressLogFiles = false,
+                DeleteUnnecessaryFiles = false,
+                CreateIRDAfterDumping = false,
+
+                // Protection Scanning Options
+                ScanArchivesForProtection = true,
+                IncludeDebugProtectionInformation = false,
+                HideDriveLetters = false,
+
+                // Redump Login Information
+                RetrieveMatchInformation = true,
+                RedumpUsername = null,
+                RedumpPassword = null,
+            };
+
+            // Try processing the standalone arguments
+            bool? standaloneProcessed = OptionsLoader.ProcessStandaloneArguments(args);
+            if (standaloneProcessed != false)
+            {
+                if (standaloneProcessed == null)
+                    DisplayHelp();
+                return;
+            }
+
+            // Setup common outputs
+            CommandOptions opts;
+            RedumpSystem? knownSystem;
+            int startIndex;
+
+            // Use interactive mode
+            if (args.Length > 0 && (args[0] == "-i" || args[0] == "--interactive"))
+            {
+                startIndex = 1;
+                opts = InteractiveMode(options, out knownSystem);
+            }
+
+            // Use normal commandline parameters
+            else
+            {
+                // Try processing the common arguments
+                bool success = OptionsLoader.ProcessCommonArguments(args, out knownSystem, out var error);
+                if (!success)
+                {
+                    DisplayHelp(error);
+                    return;
+                }
+
+                // Loop through and process options
+                startIndex = 1;
+                opts = LoadFromArguments(args, options, ref startIndex);
+            }
+
+            if (options.InternalProgram == InternalProgram.NONE)
+            {
+                DisplayHelp("A program name needs to be provided");
+                return;
+            }
+
+            // Validate the supplied credentials
+            if (options.RetrieveMatchInformation
+                && !string.IsNullOrEmpty(options.RedumpUsername)
+                && !string.IsNullOrEmpty(options.RedumpPassword))
+            {
+                bool? validated = RedumpClient.ValidateCredentials(options.RedumpUsername!, options.RedumpPassword!).GetAwaiter().GetResult();
+                string message = validated switch
+                {
+                    true => "Redump username and password accepted!",
+                    false => "Redump username and password denied!",
+                    null => "An error occurred validating your credentials!",
+                };
+
+                Console.WriteLine(message);
+            }
+
+            // Loop through all the rest of the args
+            for (int i = startIndex; i < args.Length; i++)
+            {
+                // Check for a file
+                if (!File.Exists(args[i].Trim('"')))
+                {
+                    DisplayHelp($"{args[i].Trim('"')} does not exist");
+                    return;
+                }
+
+                // Get the full file path
+                string filepath = Path.GetFullPath(args[i].Trim('"'));
+
+                // Now populate an environment
+                Drive? drive = null;
+                if (!string.IsNullOrEmpty(opts.DevicePath))
+                    drive = Drive.Create(null, opts.DevicePath!);
+
+                var env = new DumpEnvironment(options,
+                    filepath,
+                    drive,
+                    knownSystem,
+                    internalProgram: null);
+                env.SetProcessor();
+
+                // Finally, attempt to do the output dance
+                var result = env.VerifyAndSaveDumpOutput(seedInfo: opts.Seed)
+                    .ConfigureAwait(false).GetAwaiter().GetResult();
+                Console.WriteLine(result.Message);
+            }
+        }
+
+        /// <summary>
+        /// Display help for MPF.Check
+        /// </summary>
+        /// <param name="error">Error string to prefix the help text with</param>
+        private static void DisplayHelp(string? error = null)
+        {
+            if (error != null)
+                Console.WriteLine(error);
+
+            Console.WriteLine("Usage:");
+            Console.WriteLine("MPF.Check <system> [options] </path/to/output.cue/iso> ...");
+            Console.WriteLine();
+            Console.WriteLine("Standalone Options:");
+            Console.WriteLine("-h, -?, --help          Show this help text");
+            Console.WriteLine("--version               Print the program version");
+            Console.WriteLine("-lc, --listcodes        List supported comment/content site codes");
+            Console.WriteLine("-lm, --listmedia        List supported media types");
+            Console.WriteLine("-ls, --listsystems      List supported system types");
+            Console.WriteLine("-lp, --listprograms     List supported dumping program outputs");
+            Console.WriteLine("-i, --interactive       Enable interactive mode");
+            Console.WriteLine();
+
+            Console.WriteLine("Check Options:");
+            Console.WriteLine("-u, --use <program>            Dumping program output type [REQUIRED]");
+            Console.WriteLine("    --load-seed <path>         Load a seed submission JSON for user information");
+            Console.WriteLine("    --no-placeholders          Disable placeholder values in submission info");
+            Console.WriteLine("    --create-ird               Create IRD from output files (PS3 only)");
+            Console.WriteLine("    --no-retrieve              Disable retrieving match information from Redump");
+            Console.WriteLine("-c, --credentials <user> <pw>  Redump username and password (incompatible with --no-retrieve)");
+            Console.WriteLine("    --pull-all                 Pull all information from Redump (requires --credentials)");
+            Console.WriteLine("-p, --path <drivepath>         Physical drive path for additional checks");
+            Console.WriteLine("-s, --scan                     Enable copy protection scan (requires --path)");
+            Console.WriteLine("    --disable-archives         Disable scanning archives (requires --scan)");
+            Console.WriteLine("    --enable-debug             Enable debug protection information (requires --scan)");
+            Console.WriteLine("    --hide-drive-letters       Hide drive letters from scan output (requires --scan)");
+            Console.WriteLine("-x, --suffix                   Enable adding filename suffix");
+            Console.WriteLine("-j, --json                     Enable submission JSON output");
+            Console.WriteLine("    --include-artifacts        Include artifacts in JSON (requires --json)");
+            Console.WriteLine("-z, --zip                      Enable log file compression");
+            Console.WriteLine("-d, --delete                   Enable unnecessary file deletion");
+            Console.WriteLine();
+            Console.WriteLine("WARNING: Check will overwrite both any existing submission information files as well");
+            Console.WriteLine("as any log archives. Please make backups of those if you need to before running Check.");
+            Console.WriteLine();
+        }
+
+        /// <summary>
+        /// Enable interactive mode for entering information
+        /// </summary>
+        private static CommandOptions InteractiveMode(Options options, out RedumpSystem? system)
+        {
+            // Create return values
+            var opts = new CommandOptions();
+            system = null;
+
+            // These values require multiple parts to be active
+            bool scan = false,
+                enableArchives = true,
+                enableDebug = false,
+                hideDriveLetters = false;
+
+            // Create state values
+            string? result = string.Empty;
+
+        root:
+            Console.Clear();
+            Console.WriteLine("MPF.Check Interactive Mode - Main Menu");
+            Console.WriteLine("-------------------------");
+            Console.WriteLine();
+            Console.WriteLine($"1) Set system (Currently '{system}')");
+            Console.WriteLine($"2) Set dumping program (Currently '{options.InternalProgram}')");
+            Console.WriteLine($"3) Set seed path (Currently '{opts.Seed}')");
+            Console.WriteLine($"4) Add placeholders (Currently '{options.AddPlaceholders}')");
+            Console.WriteLine($"5) Create IRD (Currently '{options.CreateIRDAfterDumping}')");
+            Console.WriteLine($"6) Attempt Redump matches (Currently '{options.RetrieveMatchInformation}')");
+            Console.WriteLine($"7) Redump credentials (Currently '{options.RedumpUsername}')");
+            Console.WriteLine($"8) Pull all information (Currently '{options.PullAllInformation}')");
+            Console.WriteLine($"9) Set device path (Currently '{opts.DevicePath}')");
+            Console.WriteLine($"A) Scan for protection (Currently '{scan}')");
+            Console.WriteLine($"B) Scan archives for protection (Currently '{enableArchives}')");
+            Console.WriteLine($"C) Debug protection scan output (Currently '{enableDebug}')");
+            Console.WriteLine($"D) Hide drive letters in protection output (Currently '{hideDriveLetters}')");
+            Console.WriteLine($"E) Hide filename suffix (Currently '{options.AddFilenameSuffix}')");
+            Console.WriteLine($"F) Output submission JSON (Currently '{options.OutputSubmissionJSON}')");
+            Console.WriteLine($"G) Include JSON artifacts (Currently '{options.IncludeArtifacts}')");
+            Console.WriteLine($"H) Compress logs (Currently '{options.CompressLogFiles}')");
+            Console.WriteLine($"I) Delete unnecessary files (Currently '{options.DeleteUnnecessaryFiles}')");
+            Console.WriteLine();
+            Console.WriteLine($"Q) Exit the program");
+            Console.WriteLine($"X) Start checking");
+            Console.Write("> ");
+
+            result = Console.ReadLine();
+            switch (result)
+            {
+                case "1":
+                    goto system;
+                case "2":
+                    goto dumpingProgram;
+                case "3":
+                    goto seedPath;
+                case "4":
+                    options.AddPlaceholders = !options.AddPlaceholders;
+                    goto root;
+                case "5":
+                    options.CreateIRDAfterDumping = !options.CreateIRDAfterDumping;
+                    goto root;
+                case "6":
+                    options.RetrieveMatchInformation = !options.RetrieveMatchInformation;
+                    goto root;
+                case "7":
+                    goto redumpCredentials;
+                case "8":
+                    options.PullAllInformation = !options.PullAllInformation;
+                    goto root;
+                case "9":
+                    goto devicePath;
+                case "a":
+                case "A":
+                    scan = !scan;
+                    goto root;
+                case "b":
+                case "B":
+                    enableArchives = !enableArchives;
+                    goto root;
+                case "c":
+                case "C":
+                    enableDebug = !enableDebug;
+                    goto root;
+                case "d":
+                case "D":
+                    hideDriveLetters = !hideDriveLetters;
+                    goto root;
+                case "e":
+                case "E":
+                    options.AddFilenameSuffix = !options.AddFilenameSuffix;
+                    goto root;
+                case "f":
+                case "F":
+                    options.OutputSubmissionJSON = !options.OutputSubmissionJSON;
+                    goto root;
+                case "g":
+                case "G":
+                    options.IncludeArtifacts = !options.IncludeArtifacts;
+                    goto root;
+                case "h":
+                case "H":
+                    options.CompressLogFiles = !options.CompressLogFiles;
+                    goto root;
+                case "i":
+                case "I":
+                    options.DeleteUnnecessaryFiles = !options.DeleteUnnecessaryFiles;
+                    goto root;
+
+                case "q":
+                case "Q":
+                    Environment.Exit(0);
+                    break;
+                case "x":
+                case "X":
+                    Console.Clear();
+                    goto exit;
+                case "z":
+                case "Z":
+                    Console.WriteLine("It is pitch black. You are likely to be eaten by a grue.");
+                    Console.Write("> ");
+                    Console.ReadLine();
+                    goto root;
+                default:
+                    Console.WriteLine($"Invalid selection: {result}");
+                    Console.ReadLine();
+                    goto root;
+            }
+
+        system:
+            Console.WriteLine();
+            Console.WriteLine("Input the system and press Enter:");
+            Console.Write("> ");
+            result = Console.ReadLine();
+            system = Extensions.ToRedumpSystem(result);
+            goto root;
+
+        dumpingProgram:
+            Console.WriteLine();
+            Console.WriteLine("Input the dumping program and press Enter:");
+            Console.Write("> ");
+            result = Console.ReadLine();
+            options.InternalProgram = result.ToInternalProgram();
+            goto root;
+
+        seedPath:
+            Console.WriteLine();
+            Console.WriteLine("Input the seed path and press Enter:");
+            Console.Write("> ");
+            result = Console.ReadLine();
+            opts.Seed = Builder.CreateFromFile(result);
+            goto root;
+
+        redumpCredentials:
+            Console.WriteLine();
+            Console.WriteLine("Enter your Redumper username and press Enter:");
+            Console.Write("> ");
+            options.RedumpUsername = Console.ReadLine();
+
+            Console.WriteLine("Enter your Redumper password (hidden) and press Enter:");
+            Console.Write("> ");
+            options.RedumpPassword = string.Empty;
+            while (true)
+            {
+                var key = Console.ReadKey(true);
+                if (key.Key == ConsoleKey.Enter)
+                    break;
+
+                options.RedumpPassword += key.KeyChar;
+            }
+
+            goto root;
+
+        devicePath:
+            Console.WriteLine();
+            Console.WriteLine("Input the device path and press Enter:");
+            Console.Write("> ");
+            opts.DevicePath = Console.ReadLine();
+            goto root;
+
+        exit:
+            // Now deal with the complex options
+            options.ScanForProtection = scan && !string.IsNullOrEmpty(opts.DevicePath);
+            options.ScanArchivesForProtection = enableArchives && scan && !string.IsNullOrEmpty(opts.DevicePath);
+            options.IncludeDebugProtectionInformation = enableDebug && scan && !string.IsNullOrEmpty(opts.DevicePath);
+            options.HideDriveLetters = hideDriveLetters && scan && !string.IsNullOrEmpty(opts.DevicePath);
+
+            return opts;
+        }
+
+        /// <summary>
+        /// Load the current set of options from application arguments
+        /// </summary>
+        private static CommandOptions LoadFromArguments(string[] args, Options options, ref int startIndex)
+        {
+            // Create return values
+            var opts = new CommandOptions();
+
+            // These values require multiple parts to be active
+            bool scan = false,
+                enableArchives = true,
+                enableDebug = false,
+                hideDriveLetters = false;
+
+            // If we have no arguments, just return
+            if (args == null || args.Length == 0)
+            {
+                startIndex = 0;
+                return opts;
+            }
+
+            // If we have an invalid start index, just return
+            if (startIndex < 0 || startIndex >= args.Length)
+                return opts;
+
+            // Loop through the arguments and parse out values
+            for (; startIndex < args.Length; startIndex++)
+            {
+                // Use specific program
+                if (args[startIndex].StartsWith("-u=") || args[startIndex].StartsWith("--use="))
+                {
+                    string internalProgram = args[startIndex].Split('=')[1];
+                    options.InternalProgram = internalProgram.ToInternalProgram();
+                }
+                else if (args[startIndex] == "-u" || args[startIndex] == "--use")
+                {
+                    string internalProgram = args[startIndex + 1];
+                    options.InternalProgram = internalProgram.ToInternalProgram();
+                    startIndex++;
+                }
+
+                // Include seed info file
+                else if (args[startIndex].StartsWith("--load-seed="))
+                {
+                    string seedInfo = args[startIndex].Split('=')[1];
+                    opts.Seed = Builder.CreateFromFile(seedInfo);
+                }
+                else if (args[startIndex] == "--load-seed")
+                {
+                    string seedInfo = args[startIndex + 1];
+                    opts.Seed = Builder.CreateFromFile(seedInfo);
+                    startIndex++;
+                }
+
+                // Disable placeholder values in submission info
+                else if (args[startIndex].Equals("--no-placeholders"))
+                {
+                    options.AddPlaceholders = false;
+                }
+
+                // Create IRD from output files (PS3 only)
+                else if (args[startIndex].Equals("--create-ird"))
+                {
+                    options.CreateIRDAfterDumping = true;
+                }
+
+                // Retrieve Redump match information
+                else if (args[startIndex] == "--no-retrieve")
+                {
+                    options.RetrieveMatchInformation = false;
+                }
+
+                // Redump login
+                else if (args[startIndex].StartsWith("-c=") || args[startIndex].StartsWith("--credentials="))
+                {
+                    string[] credentials = args[startIndex].Split('=')[1].Split(';');
+                    options.RedumpUsername = credentials[0];
+                    options.RedumpPassword = credentials[1];
+                }
+                else if (args[startIndex] == "-c" || args[startIndex] == "--credentials")
+                {
+                    options.RedumpUsername = args[startIndex + 1];
+                    options.RedumpPassword = args[startIndex + 2];
+                    startIndex += 2;
+                }
+
+                // Pull all information (requires Redump login)
+                else if (args[startIndex].Equals("--pull-all"))
+                {
+                    options.PullAllInformation = true;
+                }
+
+                // Use a device path for physical checks
+                else if (args[startIndex].StartsWith("-p=") || args[startIndex].StartsWith("--path="))
+                {
+                    opts.DevicePath = args[startIndex].Split('=')[1];
+                }
+                else if (args[startIndex] == "-p" || args[startIndex] == "--path")
+                {
+                    opts.DevicePath = args[startIndex + 1];
+                    startIndex++;
+                }
+
+                // Scan for protection (requires device path)
+                else if (args[startIndex].Equals("-s") || args[startIndex].Equals("--scan"))
+                {
+                    scan = true;
+                }
+
+                // Disable scanning archives (requires --scan)
+                else if (args[startIndex].Equals("--disable-archives"))
+                {
+                    enableArchives = false;
+                }
+
+                // Enable debug protection information (requires --scan)
+                else if (args[startIndex].Equals("--enable-debug"))
+                {
+                    enableDebug = true;
+                }
+
+                // Hide drive letters from scan output (requires --scan)
+                else if (args[startIndex].Equals("--hide-drive-letters"))
+                {
+                    hideDriveLetters = true;
+                }
+
+                // Add filename suffix
+                else if (args[startIndex].Equals("-x") || args[startIndex].Equals("--suffix"))
+                {
+                    options.AddFilenameSuffix = true;
+                }
+
+                // Output submission JSON
+                else if (args[startIndex].Equals("-j") || args[startIndex].Equals("--json"))
+                {
+                    options.OutputSubmissionJSON = true;
+                }
+
+                // Include JSON artifacts
+                else if (args[startIndex].Equals("--include-artifacts"))
+                {
+                    options.IncludeArtifacts = true;
+                }
+
+                // Compress log and extraneous files
+                else if (args[startIndex].Equals("-z") || args[startIndex].Equals("--zip"))
+                {
+                    options.CompressLogFiles = true;
+                }
+
+                // Delete unnecessary files
+                else if (args[startIndex].Equals("-d") || args[startIndex].Equals("--delete"))
+                {
+                    options.DeleteUnnecessaryFiles = true;
+                }
+
+                // Default, we fall out
+                else
+                {
+                    break;
+                }
+            }
+
+            // Now deal with the complex options
+            options.ScanForProtection = scan && !string.IsNullOrEmpty(opts.DevicePath);
+            options.ScanArchivesForProtection = enableArchives && scan && !string.IsNullOrEmpty(opts.DevicePath);
+            options.IncludeDebugProtectionInformation = enableDebug && scan && !string.IsNullOrEmpty(opts.DevicePath);
+            options.HideDriveLetters = hideDriveLetters && scan && !string.IsNullOrEmpty(opts.DevicePath);
+
+            return opts;
+        }
+
+        /// <summary>
+        /// Represents commandline options
+        /// </summary>
+        private class CommandOptions
+        {
+            /// <summary>
+            /// Seed submission info from an input file
+            /// </summary>
+            public SubmissionInfo? Seed { get; set; } = null;
+
+            /// <summary>
+            /// Path to the device to scan
+            /// </summary>
+            public string? DevicePath { get; set; } = null;
+        }
+    }
+}

MPF.ExecutionContexts.Test/AaruTests.cs

@@ -0,0 +1,517 @@
+using System.Collections.Generic;
+using MPF.ExecutionContexts.Aaru;
+using SabreTools.RedumpLib.Data;
+using Xunit;
+
+namespace MPF.ExecutionContexts.Test
+{
+    public class AaruTests
+    {
+        #region Converters.Extension
+
+        [Theory]
+        [InlineData(null, ".aaruf")]
+        [InlineData(MediaType.CDROM, ".aaruf")]
+        [InlineData(MediaType.GDROM, ".aaruf")]
+        [InlineData(MediaType.DVD, ".aaruf")]
+        [InlineData(MediaType.HDDVD, ".aaruf")]
+        [InlineData(MediaType.BluRay, ".aaruf")]
+        [InlineData(MediaType.FloppyDisk, ".aaruf")]
+        [InlineData(MediaType.HardDisk, ".aaruf")]
+        [InlineData(MediaType.ApertureCard, ".aaruf")]
+        public void ExtensionTest(MediaType? type, string expected)
+        {
+            string actual = Converters.Extension(type);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region Default Values
+
+        private static Dictionary<string, string?> AllOptions = new()
+        {
+            [SettingConstants.EnableDebug] = "true",
+            [SettingConstants.EnableVerbose] = "true",
+            [SettingConstants.ForceDumping] = "true",
+            [SettingConstants.RereadCount] = "1000",
+            [SettingConstants.StripPersonalData] = "true",
+        };
+
+        [Theory]
+        [InlineData(null, null, null, "filename.bin", null, null)]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, "/dev/sr0", "filename.bin", 2, "--debug True --verbose True media dump --force True --private True --store-encrypted True --title-keys False --trim True --speed 2 --retry-passes 1000 /dev/sr0 \"filename.bin\"")]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, "/dev/sr0", "filename.bin", 2, "--debug True --verbose True media dump --force True --private True --store-encrypted True --title-keys False --trim True --speed 2 --retry-passes 1000 /dev/sr0 \"filename.bin\"")]
+        [InlineData(RedumpSystem.SegaDreamcast, MediaType.GDROM, "/dev/sr0", "filename.bin", 2, "--debug True --verbose True media dump --force True --private True --store-encrypted True --title-keys False --trim True --speed 2 --retry-passes 1000 /dev/sr0 \"filename.bin\"")]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, "/dev/sr0", "filename.bin", 2, "--debug True --verbose True media dump --force True --private True --store-encrypted True --title-keys False --trim True --speed 2 --retry-passes 1000 /dev/sr0 \"filename.bin\"")]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, "/dev/sr0", "filename.bin", 2, "--debug True --verbose True media dump --force True --private True --store-encrypted True --title-keys False --trim True --speed 2 --retry-passes 1000 /dev/sr0 \"filename.bin\"")]
+        [InlineData(RedumpSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc, "/dev/sr0", "filename.bin", 2, "--debug True --verbose True media dump --force True --private True --store-encrypted True --title-keys False --trim True --speed 2 --retry-passes 1000 /dev/sr0 \"filename.bin\"")]
+        [InlineData(RedumpSystem.NintendoWii, MediaType.NintendoWiiOpticalDisc, "/dev/sr0", "filename.bin", 2, "--debug True --verbose True media dump --force True --private True --store-encrypted True --title-keys False --trim True --speed 2 --retry-passes 1000 /dev/sr0 \"filename.bin\"")]
+        [InlineData(RedumpSystem.NintendoWiiU, MediaType.NintendoWiiUOpticalDisc, "/dev/sr0", "filename.bin", 2, "--debug True --verbose True media dump --force True --private True --store-encrypted True --title-keys False --trim True --speed 2 --retry-passes 1000 /dev/sr0 \"filename.bin\"")]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.FloppyDisk, "/dev/sr0", "filename.bin", 2, "--debug True --verbose True media dump --force True --private True --store-encrypted True --title-keys False --trim True --speed 2 --retry-passes 1000 /dev/sr0 \"filename.bin\"")]
+        public void DefaultValueTest(RedumpSystem? system,
+            MediaType? type,
+            string? drivePath,
+            string filename,
+            int? driveSpeed,
+            string? expected)
+        {
+            var context = new ExecutionContext(system, type, drivePath, filename, driveSpeed, AllOptions);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region Archive Family
+
+        [Theory]
+        [InlineData("arc info filename.bin")]
+        [InlineData("arc info \"filename.bin\"")]
+        [InlineData("archive info filename.bin")]
+        [InlineData("archive info \"filename.bin\"")]
+        public void ArchiveInfoTest(string parameters)
+        {
+            string? expected = "archive info \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Database Family
+
+        [Theory]
+        [InlineData("db stats")]
+        [InlineData("database stats")]
+        public void DatabaseStatsTest(string parameters)
+        {
+            string? expected = "database stats";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("db update --clear --clear-all")]
+        [InlineData("db update --clear true --clear-all true")]
+        [InlineData("database update --clear --clear-all")]
+        [InlineData("database update --clear true --clear-all true")]
+        public void DatabaseUpdateTest(string parameters)
+        {
+            string? expected = "database update --clear True --clear-all True";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Device Family
+
+        [Theory]
+        [InlineData("dev info -w prefix filename.bin")]
+        [InlineData("dev info --output-prefix prefix filename.bin")]
+        [InlineData("device info -w prefix filename.bin")]
+        [InlineData("device info --output-prefix prefix filename.bin")]
+        public void DeviceInfoTest(string parameters)
+        {
+            string? expected = "device info --output-prefix \"prefix\" filename.bin";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("dev list localhost")]
+        [InlineData("device list localhost")]
+        public void DeviceListTest(string parameters)
+        {
+            string? expected = "device list \"localhost\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("dev report -t filename.bin")]
+        [InlineData("dev report -t true filename.bin")]
+        [InlineData("dev report --trap-disc filename.bin")]
+        [InlineData("dev report --trap-disc true filename.bin")]
+        [InlineData("device report -t filename.bin")]
+        [InlineData("device report -t true filename.bin")]
+        [InlineData("device report --trap-disc filename.bin")]
+        [InlineData("device report --trap-disc true filename.bin")]
+        public void DeviceReportTest(string parameters)
+        {
+            string? expected = "device report --trap-disc True filename.bin";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Filesystem Family
+
+        [Theory]
+        [InlineData("fi extract -e enc -x -n ns -O opts input output")]
+        [InlineData("fi extract -e enc -x true -n ns -O opts input output")]
+        [InlineData("fi extract --encoding enc --xattrs --namespace ns --options opts input output")]
+        [InlineData("fi extract --encoding enc --xattrs true --namespace ns --options opts input output")]
+        [InlineData("fs extract -e enc -x -n ns -O opts input output")]
+        [InlineData("fs extract -e enc -x true -n ns -O opts input output")]
+        [InlineData("fs extract --encoding enc --xattrs --namespace ns --options opts input output")]
+        [InlineData("fs extract --encoding enc --xattrs true --namespace ns --options opts input output")]
+        [InlineData("filesystem extract -e enc -x -n ns -O opts input output")]
+        [InlineData("filesystem extract -e enc -x true -n ns -O opts input output")]
+        [InlineData("filesystem extract --encoding enc --xattrs --namespace ns --options opts input output")]
+        [InlineData("filesystem extract --encoding enc --xattrs true --namespace ns --options opts input output")]
+        public void FilesystemExtractTest(string parameters)
+        {
+            string? expected = "filesystem extract --xattrs True --encoding \"enc\" --namespace \"ns\" --options \"opts\" \"input\" \"output\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("fi info -e enc -x -n ns -O opts input")]
+        [InlineData("fi info -e enc -x true -n ns -O opts input")]
+        [InlineData("fi info --encoding enc --xattrs --namespace ns --options opts input")]
+        [InlineData("fi info --encoding enc --xattrs true --namespace ns --options opts input")]
+        [InlineData("fs info -e enc -x -n ns -O opts input")]
+        [InlineData("fs info -e enc -x true -n ns -O opts input")]
+        [InlineData("fs info --encoding enc --xattrs --namespace ns --options opts input")]
+        [InlineData("fs info --encoding enc --xattrs true --namespace ns --options opts input")]
+        [InlineData("filesystem info -e enc -x -n ns -O opts input")]
+        [InlineData("filesystem info -e enc -x true -n ns -O opts input")]
+        [InlineData("filesystem info --encoding enc --xattrs --namespace ns --options opts input")]
+        [InlineData("filesystem info --encoding enc --xattrs true --namespace ns --options opts input")]
+        public void FilesystemInfoTest(string parameters)
+        {
+            string? expected = "filesystem info --xattrs True --encoding \"enc\" --namespace \"ns\" --options \"opts\" \"input\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("fi ls -e enc -f -l -p input")]
+        [InlineData("fi list -e enc -f -l -p input")]
+        [InlineData("fi ls -e enc -f true -l true -p true input")]
+        [InlineData("fi list -e enc -f true -l true -p true input")]
+        [InlineData("fi ls --encoding enc --filesystems --long-format --partitions input")]
+        [InlineData("fi list --encoding enc --filesystems --long-format --partitions input")]
+        [InlineData("fi ls --encoding enc --filesystems true --long-format true --partitions true input")]
+        [InlineData("fi list --encoding enc --filesystems true --long-format true --partitions true input")]
+        [InlineData("fs ls -e enc -f -l -p input")]
+        [InlineData("fs list -e enc -f -l -p input")]
+        [InlineData("fs ls -e enc -f true -l true -p true input")]
+        [InlineData("fs list -e enc -f true -l true -p true input")]
+        [InlineData("fs ls --encoding enc --filesystems --long-format --partitions input")]
+        [InlineData("fs list --encoding enc --filesystems --long-format --partitions input")]
+        [InlineData("fs ls --encoding enc --filesystems true --long-format true --partitions true input")]
+        [InlineData("fs list --encoding enc --filesystems true --long-format true --partitions true input")]
+        [InlineData("filesystem ls -e enc -f -l -p input")]
+        [InlineData("filesystem list -e enc -f -l -p input")]
+        [InlineData("filesystem ls -e enc -f true -l true -p true input")]
+        [InlineData("filesystem list -e enc -f true -l true -p true input")]
+        [InlineData("filesystem ls --encoding enc --filesystems --long-format --partitions input")]
+        [InlineData("filesystem list --encoding enc --filesystems --long-format --partitions input")]
+        [InlineData("filesystem ls --encoding enc --filesystems true --long-format true --partitions true input")]
+        [InlineData("filesystem list --encoding enc --filesystems true --long-format true --partitions true input")]
+        public void FilesystemListTest(string parameters)
+        {
+            string? expected = "filesystem list --filesystems True --long-format True --partitions True --encoding \"enc\" \"input\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("fi options")]
+        [InlineData("fs options")]
+        [InlineData("filesystem options")]
+        public void FilesystemOptionsTest(string parameters)
+        {
+            string? expected = "filesystem options";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Image Family
+
+        [Theory]
+        [InlineData("i chk -a --crc16 -c --crc64 --fletcher16 --fletcher32 -m -t -s --sha256 --sha384 --sha512 -f -w filename.bin")]
+        [InlineData("i chk -a true --crc16 true -c true --crc64 true --fletcher16 true --fletcher32 true -m true -t true -s true --sha256 true --sha384 true --sha512 true -f true -w true filename.bin")]
+        [InlineData("i chk --adler32 --crc16 --crc32 --crc64 --fletcher16 --fletcher32 --md5 --separated-tracks --sha1 --sha256 --sha384 --sha512 --spamsum --whole-disc filename.bin")]
+        [InlineData("i chk --adler32 true --crc16 true --crc32 true --crc64 true --fletcher16 true --fletcher32 true --md5 true --separated-tracks true --sha1 true --sha256 true --sha384 true --sha512 true --spamsum true --whole-disc true filename.bin")]
+        [InlineData("i checksum -a --crc16 -c --crc64 --fletcher16 --fletcher32 -m -t -s --sha256 --sha384 --sha512 -f -w filename.bin")]
+        [InlineData("i checksum -a true --crc16 true -c true --crc64 true --fletcher16 true --fletcher32 true -m true -t true -s true --sha256 true --sha384 true --sha512 true -f true -w true filename.bin")]
+        [InlineData("i checksum --adler32 --crc16 --crc32 --crc64 --fletcher16 --fletcher32 --md5 --separated-tracks --sha1 --sha256 --sha384 --sha512 --spamsum --whole-disc filename.bin")]
+        [InlineData("i checksum --adler32 true --crc16 true --crc32 true --crc64 true --fletcher16 true --fletcher32 true --md5 true --separated-tracks true --sha1 true --sha256 true --sha384 true --sha512 true --spamsum true --whole-disc true filename.bin")]
+        [InlineData("image chk -a --crc16 -c --crc64 --fletcher16 --fletcher32 -m -t -s --sha256 --sha384 --sha512 -f -w filename.bin")]
+        [InlineData("image chk -a true --crc16 true -c true --crc64 true --fletcher16 true --fletcher32 true -m true -t true -s true --sha256 true --sha384 true --sha512 true -f true -w true filename.bin")]
+        [InlineData("image chk --adler32 --crc16 --crc32 --crc64 --fletcher16 --fletcher32 --md5 --separated-tracks --sha1 --sha256 --sha384 --sha512 --spamsum --whole-disc filename.bin")]
+        [InlineData("image chk --adler32 true --crc16 true --crc32 true --crc64 true --fletcher16 true --fletcher32 true --md5 true --separated-tracks true --sha1 true --sha256 true --sha384 true --sha512 true --spamsum true --whole-disc true filename.bin")]
+        [InlineData("image checksum -a --crc16 -c --crc64 --fletcher16 --fletcher32 -m -t -s --sha256 --sha384 --sha512 -f -w filename.bin")]
+        [InlineData("image checksum -a true --crc16 true -c true --crc64 true --fletcher16 true --fletcher32 true -m true -t true -s true --sha256 true --sha384 true --sha512 true -f true -w true filename.bin")]
+        [InlineData("image checksum --adler32 --crc16 --crc32 --crc64 --fletcher16 --fletcher32 --md5 --separated-tracks --sha1 --sha256 --sha384 --sha512 --spamsum --whole-disc filename.bin")]
+        [InlineData("image checksum --adler32 true --crc16 true --crc32 true --crc64 true --fletcher16 true --fletcher32 true --md5 true --separated-tracks true --sha1 true --sha256 true --sha384 true --sha512 true --spamsum true --whole-disc true filename.bin")]
+        public void ImageChecksumTest(string parameters)
+        {
+            string? expected = "image checksum --adler32 True --crc16 True --crc32 True --crc64 True --fletcher16 True --fletcher32 True --md5 True --separated-tracks True --sha1 True --sha256 True --sha384 True --sha512 True --spamsum True --whole-disc True \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("i cmp input1.bin input2.bin")]
+        [InlineData("i compare input1.bin input2.bin")]
+        [InlineData("image cmp input1.bin input2.bin")]
+        [InlineData("image compare input1.bin input2.bin")]
+        public void ImageCompareTest(string parameters)
+        {
+            string? expected = "image compare \"input1.bin\" \"input2.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("i convert --comments co -c 0 --creator cr --drive-manufacturer dm --drive-model dm --drive-revision dr --drive-serial ds --fix-subchannel --fix-subchannel-crc --fix-subchannel-position -f -p fmt --generate-subchannels -g geo --media-barcode mb --media-lastsequence 0 --media-manufacturer mm --media-model mm --media-partnumber mpn --media-sequence 0 --media-serial ms --media-title mt -O opt -r resume -x cicm input1.bin input2.bin")]
+        [InlineData("i convert --comments co -c 0 --creator cr --drive-manufacturer dm --drive-model dm --drive-revision dr --drive-serial ds --fix-subchannel true --fix-subchannel-crc true --fix-subchannel-position true -f true -p fmt --generate-subchannels true -g geo --media-barcode mb --media-lastsequence 0 --media-manufacturer mm --media-model mm --media-partnumber mpn --media-sequence 0 --media-serial ms --media-title mt -O opt -r resume -x cicm input1.bin input2.bin")]
+        [InlineData("i convert --comments co --count 0 --creator cr --drive-manufacturer dm --drive-model dm --drive-revision dr --drive-serial ds --fix-subchannel --fix-subchannel-crc --fix-subchannel-position --force --format fmt --generate-subchannels --geometry geo --media-barcode mb --media-lastsequence 0 --media-manufacturer mm --media-model mm --media-partnumber mpn --media-sequence 0 --media-serial ms --media-title mt --options opt --resume-file resume --cicm-xml cicm input1.bin input2.bin")]
+        [InlineData("i convert --comments co --count 0 --creator cr --drive-manufacturer dm --drive-model dm --drive-revision dr --drive-serial ds --fix-subchannel true --fix-subchannel-crc true --fix-subchannel-position true --force true --format fmt --generate-subchannels true --geometry geo --media-barcode mb --media-lastsequence 0 --media-manufacturer mm --media-model mm --media-partnumber mpn --media-sequence 0 --media-serial ms --media-title mt --options opt --resume-file resume --cicm-xml cicm input1.bin input2.bin")]
+        [InlineData("image convert --comments co -c 0 --creator cr --drive-manufacturer dm --drive-model dm --drive-revision dr --drive-serial ds --fix-subchannel --fix-subchannel-crc --fix-subchannel-position -f -p fmt --generate-subchannels -g geo --media-barcode mb --media-lastsequence 0 --media-manufacturer mm --media-model mm --media-partnumber mpn --media-sequence 0 --media-serial ms --media-title mt -O opt -r resume -x cicm input1.bin input2.bin")]
+        [InlineData("image convert --comments co -c 0 --creator cr --drive-manufacturer dm --drive-model dm --drive-revision dr --drive-serial ds --fix-subchannel true --fix-subchannel-crc true --fix-subchannel-position true -f true -p fmt --generate-subchannels true -g geo --media-barcode mb --media-lastsequence 0 --media-manufacturer mm --media-model mm --media-partnumber mpn --media-sequence 0 --media-serial ms --media-title mt -O opt -r resume -x cicm input1.bin input2.bin")]
+        [InlineData("image convert --comments co --count 0 --creator cr --drive-manufacturer dm --drive-model dm --drive-revision dr --drive-serial ds --fix-subchannel --fix-subchannel-crc --fix-subchannel-position --force --format fmt --generate-subchannels --geometry geo --media-barcode mb --media-lastsequence 0 --media-manufacturer mm --media-model mm --media-partnumber mpn --media-sequence 0 --media-serial ms --media-title mt --options opt --resume-file resume --cicm-xml cicm input1.bin input2.bin")]
+        [InlineData("image convert --comments co --count 0 --creator cr --drive-manufacturer dm --drive-model dm --drive-revision dr --drive-serial ds --fix-subchannel true --fix-subchannel-crc true --fix-subchannel-position true --force true --format fmt --generate-subchannels true --geometry geo --media-barcode mb --media-lastsequence 0 --media-manufacturer mm --media-model mm --media-partnumber mpn --media-sequence 0 --media-serial ms --media-title mt --options opt --resume-file resume --cicm-xml cicm input1.bin input2.bin")]
+        public void ImageConvertTest(string parameters)
+        {
+            string? expected = "image convert --fix-subchannel True --fix-subchannel-crc True --fix-subchannel-position True --force True --generate-subchannels True --count 0 --media-lastsequence 0 --media-sequence 0 --comments \"co\" --creator \"cr\" --drive-manufacturer \"dm\" --drive-model \"dm\" --drive-revision \"dr\" --drive-serial \"ds\" --format \"fmt\" --geometry \"geo\" --media-barcode \"mb\" --media-manufacturer \"mm\" --media-model \"mm\" --media-partnumber \"mpn\" --media-serial \"ms\" --media-title \"mt\" --options \"opt\" --resume-file \"resume\" --cicm-xml \"cicm\" \"input1.bin\" \"input2.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("i create-sidecar -b 0 -e enc -t filename.bin")]
+        [InlineData("i create-sidecar -b 0 -e enc -t true filename.bin")]
+        [InlineData("i create-sidecar --block-size 0 --encoding enc --tape filename.bin")]
+        [InlineData("i create-sidecar --block-size 0 --encoding enc --tape true filename.bin")]
+        [InlineData("image create-sidecar -b 0 -e enc -t filename.bin")]
+        [InlineData("image create-sidecar -b 0 -e enc -t true filename.bin")]
+        [InlineData("image create-sidecar --block-size 0 --encoding enc --tape filename.bin")]
+        [InlineData("image create-sidecar --block-size 0 --encoding enc --tape true filename.bin")]
+        public void ImageCreateSidecarTest(string parameters)
+        {
+            string? expected = "image create-sidecar --tape True --block-size 0 --encoding \"enc\" \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("i decode -f -l all -p -s 0 filename.bin")]
+        [InlineData("i decode -f true -l all -p true -s 0 filename.bin")]
+        [InlineData("i decode --disk-tags --length all --sector-tags --start 0 filename.bin")]
+        [InlineData("i decode --disk-tags true --length all --sector-tags true --start 0 filename.bin")]
+        [InlineData("image decode -f -l all -p -s 0 filename.bin")]
+        [InlineData("image decode -f true -l all -p true -s 0 filename.bin")]
+        [InlineData("image decode --disk-tags --length all --sector-tags --start 0 filename.bin")]
+        [InlineData("image decode --disk-tags true --length all --sector-tags true --start 0 filename.bin")]
+        public void ImageDecodeTest(string parameters)
+        {
+            string? expected = "image decode --disk-tags True --sector-tags True --length all --start 0 \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("i entropy -p -t -w filename.bin")]
+        [InlineData("i entropy -p true -t true -w true filename.bin")]
+        [InlineData("i entropy --duplicated-sectors --separated-tracks --whole-disc filename.bin")]
+        [InlineData("i entropy --duplicated-sectors true --separated-tracks true --whole-disc true filename.bin")]
+        [InlineData("image entropy -p -t -w filename.bin")]
+        [InlineData("image entropy -p true -t true -w true filename.bin")]
+        [InlineData("image entropy --duplicated-sectors --separated-tracks --whole-disc filename.bin")]
+        [InlineData("image entropy --duplicated-sectors true --separated-tracks true --whole-disc true filename.bin")]
+        public void ImageEntropyTest(string parameters)
+        {
+            string? expected = "image entropy --duplicated-sectors True --separated-tracks True --whole-disc True \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("i info filename.bin")]
+        [InlineData("image info filename.bin")]
+        public void ImageInfoTest(string parameters)
+        {
+            string? expected = "image info \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("i options")]
+        [InlineData("image options")]
+        public void ImageOptionsTest(string parameters)
+        {
+            string? expected = "image options";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("i print -l 0 -r -s 0 -w 0 filename.bin")]
+        [InlineData("i print -l 0 -r true -s 0 -w 0 filename.bin")]
+        [InlineData("i print --length 0 --long-sectors --start 0 --width 0 filename.bin")]
+        [InlineData("i print --length 0 --long-sectors true --start 0 --width 0 filename.bin")]
+        [InlineData("image print -l 0 -r -s 0 -w 0 filename.bin")]
+        [InlineData("image print -l 0 -r true -s 0 -w 0 filename.bin")]
+        [InlineData("image print --length 0 --long-sectors --start 0 --width 0 filename.bin")]
+        [InlineData("image print --length 0 --long-sectors true --start 0 --width 0 filename.bin")]
+        public void ImagePrintTest(string parameters)
+        {
+            string? expected = "image print --long-sectors True --width 0 --length 0 --start 0 \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("i verify -w -s filename.bin")]
+        [InlineData("i verify -w true -s true filename.bin")]
+        [InlineData("i verify --verify-disc --verify-sectors filename.bin")]
+        [InlineData("i verify --verify-disc true --verify-sectors true filename.bin")]
+        [InlineData("image verify -w -s filename.bin")]
+        [InlineData("image verify -w true -s true filename.bin")]
+        [InlineData("image verify --verify-disc --verify-sectors filename.bin")]
+        [InlineData("image verify --verify-disc true --verify-sectors true filename.bin")]
+        public void ImageVerifyTest(string parameters)
+        {
+            string? expected = "image verify --verify-disc True --verify-sectors True \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Media Family
+
+        [Theory]
+        [InlineData("m dump --eject -e enc --first-pregap --fix-offset --fix-subchannel --fix-subchannel-crc --fix-subchannel-position -f --generate-subchannels --max-blocks 0 --metadata -O opt --persistent --private -r -p 0 --retry-subchannel -k 0 --skip-cdiready-hole --speed 0 -s --store-encrypted --subchannel any --title-keys --trim --use-buffered-reads -x cicm input output.bin")]
+        [InlineData("m dump --eject true -e enc --first-pregap true --fix-offset true --fix-subchannel true --fix-subchannel-crc true --fix-subchannel-position true -f true --generate-subchannels true --max-blocks 0 --metadata true -O opt --persistent true --private true -r true -p 0 --retry-subchannel true -k 0 --skip-cdiready-hole true --speed 0 -s true --store-encrypted true --subchannel any --title-keys true --trim true --use-buffered-reads true -x cicm input output.bin")]
+        [InlineData("m dump --eject --encoding enc --first-pregap --fix-offset --fix-subchannel --fix-subchannel-crc --fix-subchannel-position --force --generate-subchannels --max-blocks 0 --metadata --options opt --persistent --private --resume --retry-passes 0 --retry-subchannel --skip 0 --skip-cdiready-hole --speed 0 --stop-on-error --store-encrypted --subchannel any --title-keys --trim --use-buffered-reads --cicm-xml cicm input output.bin")]
+        [InlineData("m dump --eject true --encoding enc --first-pregap true --fix-offset true --fix-subchannel true --fix-subchannel-crc true --fix-subchannel-position true --force true --generate-subchannels true --max-blocks 0 --metadata true --options opt --persistent true --private true --resume true --retry-passes 0 --retry-subchannel true --skip 0 --skip-cdiready-hole true --speed 0 --stop-on-error true --store-encrypted true --subchannel any --title-keys true --trim true --use-buffered-reads true --cicm-xml cicm input output.bin")]
+        [InlineData("media dump --eject -e enc --first-pregap --fix-offset --fix-subchannel --fix-subchannel-crc --fix-subchannel-position -f --generate-subchannels --max-blocks 0 --metadata -O opt --persistent --private -r -p 0 --retry-subchannel -k 0 --skip-cdiready-hole --speed 0 -s --store-encrypted --subchannel any --title-keys --trim --use-buffered-reads -x cicm input output.bin")]
+        [InlineData("media dump --eject true -e enc --first-pregap true --fix-offset true --fix-subchannel true --fix-subchannel-crc true --fix-subchannel-position true -f true --generate-subchannels true --max-blocks 0 --metadata true -O opt --persistent true --private true -r true -p 0 --retry-subchannel true -k 0 --skip-cdiready-hole true --speed 0 -s true --store-encrypted true --subchannel any --title-keys true --trim true --use-buffered-reads true -x cicm input output.bin")]
+        [InlineData("media dump --eject --encoding enc --first-pregap --fix-offset --fix-subchannel --fix-subchannel-crc --fix-subchannel-position --force --generate-subchannels --max-blocks 0 --metadata --options opt --persistent --private --resume --retry-passes 0 --retry-subchannel --skip 0 --skip-cdiready-hole --speed 0 --stop-on-error --store-encrypted --subchannel any --title-keys --trim --use-buffered-reads --cicm-xml cicm input output.bin")]
+        [InlineData("media dump --eject true --encoding enc --first-pregap true --fix-offset true --fix-subchannel true --fix-subchannel-crc true --fix-subchannel-position true --force true --generate-subchannels true --max-blocks 0 --metadata true --options opt --persistent true --private true --resume true --retry-passes 0 --retry-subchannel true --skip 0 --skip-cdiready-hole true --speed 0 --stop-on-error true --store-encrypted true --subchannel any --title-keys true --trim true --use-buffered-reads true --cicm-xml cicm input output.bin")]
+        public void MediaDumpTest(string parameters)
+        {
+            string? expected = "media dump --eject True --first-pregap True --fix-offset True --fix-subchannel True --fix-subchannel-crc True --fix-subchannel-position True --force True --generate-subchannels True --metadata True --persistent True --private True --resume True --retry-subchannel True --skip-cdiready-hole True --stop-on-error True --store-encrypted True --title-keys True --trim True --use-buffered-reads True --speed 0 --retry-passes 0 --max-blocks 0 --skip 0 --encoding \"enc\" --options \"opt\" --subchannel \"any\" --cicm-xml \"cicm\" input \"output.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("m info -w prefix input")]
+        [InlineData("m info --output-prefix prefix input")]
+        [InlineData("media info -w prefix input")]
+        [InlineData("media info --output-prefix prefix input")]
+        public void MediaInfoTest(string parameters)
+        {
+            string? expected = "media info --output-prefix \"prefix\" input";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("m scan -b ibg -m mhdd --use-buffered-reads input")]
+        [InlineData("m scan -b ibg -m mhdd --use-buffered-reads true input")]
+        [InlineData("m scan --ibg-log ibg --mhdd-log mhdd --use-buffered-reads input")]
+        [InlineData("m scan --ibg-log ibg --mhdd-log mhdd --use-buffered-reads true input")]
+        [InlineData("media scan -b ibg -m mhdd --use-buffered-reads input")]
+        [InlineData("media scan -b ibg -m mhdd --use-buffered-reads true input")]
+        [InlineData("media scan --ibg-log ibg --mhdd-log mhdd --use-buffered-reads input")]
+        [InlineData("media scan --ibg-log ibg --mhdd-log mhdd --use-buffered-reads true input")]
+        public void MediaScanTest(string parameters)
+        {
+            string? expected = "media scan --use-buffered-reads True --ibg-log \"ibg\" --mhdd-log \"mhdd\" input";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Standalone Commands
+
+        [Theory]
+        [InlineData("--debug --help --verbose --version formats")]
+        [InlineData("--debug true --help true --verbose true --version true formats")]
+        public void PreCommandFlagsTest(string parameters)
+        {
+            string? expected = "--debug True --help True --verbose True --version True formats";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("configure", "configure")]
+        [InlineData("formats", "formats")]
+        [InlineData("list-encodings", "list-encodings")]
+        [InlineData("list-namespaces", "list-namespaces")]
+        [InlineData("remote localhost", "remote \"localhost\"")]
+        public void StandaloneCommandsTest(string parameters, string? expected)
+        {
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts.Test/BaseExecutionContextTests.cs

@@ -0,0 +1,464 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace MPF.ExecutionContexts.Test
+{
+    public class BaseExecutionContextTests
+    {
+        #region GetBooleanSetting
+
+        [Fact]
+        public void GetBooleanSetting_InvalidDict_Default()
+        {
+            Dictionary<string, string?> settings = [];
+            string key = "key";
+            bool defaultValue = false;
+
+            bool actual = BaseExecutionContext.GetBooleanSetting(settings, key, defaultValue);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void GetBooleanSetting_InvalidKey_Default()
+        {
+            Dictionary<string, string?> settings = new()
+            {
+                ["key2"] = "true",
+            };
+            string key = "key";
+            bool defaultValue = false;
+
+            bool actual = BaseExecutionContext.GetBooleanSetting(settings, key, defaultValue);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void GetBooleanSetting_NullValue_Default()
+        {
+            Dictionary<string, string?> settings = new()
+            {
+                ["key"] = null,
+            };
+            string key = "key";
+            bool defaultValue = false;
+
+            bool actual = BaseExecutionContext.GetBooleanSetting(settings, key, defaultValue);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void GetBooleanSetting_InvalidValue_Default()
+        {
+            Dictionary<string, string?> settings = new()
+            {
+                ["key"] = "invalid",
+            };
+            string key = "key";
+            bool defaultValue = false;
+
+            bool actual = BaseExecutionContext.GetBooleanSetting(settings, key, defaultValue);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void GetBooleanSetting_ValidValue_Parsed()
+        {
+            Dictionary<string, string?> settings = new()
+            {
+                ["key"] = "true",
+            };
+            string key = "key";
+            bool defaultValue = false;
+
+            bool actual = BaseExecutionContext.GetBooleanSetting(settings, key, defaultValue);
+            Assert.True(actual);
+        }
+
+        #endregion
+
+        #region GetInt32Setting
+
+        [Fact]
+        public void GetInt32Setting_InvalidDict_Default()
+        {
+            Dictionary<string, string?> settings = [];
+            string key = "key";
+            int defaultValue = -1;
+
+            int actual = BaseExecutionContext.GetInt32Setting(settings, key, defaultValue);
+            Assert.Equal(-1, actual);
+        }
+
+        [Fact]
+        public void GetInt32Setting_InvalidKey_Default()
+        {
+            Dictionary<string, string?> settings = new()
+            {
+                ["key2"] = "12345",
+            };
+            string key = "key";
+            int defaultValue = -1;
+
+            int actual = BaseExecutionContext.GetInt32Setting(settings, key, defaultValue);
+            Assert.Equal(-1, actual);
+        }
+
+        [Fact]
+        public void GetInt32Setting_NullValue_Default()
+        {
+            Dictionary<string, string?> settings = new()
+            {
+                ["key"] = null,
+            };
+            string key = "key";
+            int defaultValue = -1;
+
+            int actual = BaseExecutionContext.GetInt32Setting(settings, key, defaultValue);
+            Assert.Equal(-1, actual);
+        }
+
+        [Fact]
+        public void GetInt32Setting_InvalidValue_Default()
+        {
+            Dictionary<string, string?> settings = new()
+            {
+                ["key"] = "invalid",
+            };
+            string key = "key";
+            int defaultValue = -1;
+
+            int actual = BaseExecutionContext.GetInt32Setting(settings, key, defaultValue);
+            Assert.Equal(-1, actual);
+        }
+
+        [Fact]
+        public void GetInt32Setting_ValidValue_Parsed()
+        {
+            int expected = 12345;
+            Dictionary<string, string?> settings = new()
+            {
+                ["key"] = "12345",
+            };
+            string key = "key";
+            int defaultValue = -1;
+
+            int actual = BaseExecutionContext.GetInt32Setting(settings, key, defaultValue);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region GetStringSetting
+
+        [Fact]
+        public void GetStringSetting_InvalidDict_Default()
+        {
+            Dictionary<string, string?> settings = [];
+            string key = "key";
+            string? defaultValue = null;
+
+            string? actual = BaseExecutionContext.GetStringSetting(settings, key, defaultValue);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void GetStringSetting_InvalidKey_Default()
+        {
+            Dictionary<string, string?> settings = new()
+            {
+                ["key2"] = "12345",
+            };
+            string key = "key";
+            string? defaultValue = null;
+
+            string? actual = BaseExecutionContext.GetStringSetting(settings, key, defaultValue);
+            Assert.Null(actual);
+        }
+
+        [Fact]
+        public void GetStringSetting_ValidValue_Rturned()
+        {
+            string expected = "expected";
+            Dictionary<string, string?> settings = new()
+            {
+                ["key"] = "expected",
+            };
+            string key = "key";
+            string? defaultValue = null;
+
+            string? actual = BaseExecutionContext.GetStringSetting(settings, key, defaultValue);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region SplitParameterString
+
+        [Fact]
+        public void SplitParameterString_Empty_Empty()
+        {
+            string parameters = string.Empty;
+            string[] actual = BaseExecutionContext.SplitParameterString(parameters);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void SplitParameterString_NoSplit_Single()
+        {
+            string expected = "single";
+            string parameters = "single";
+            string[] actual = BaseExecutionContext.SplitParameterString(parameters);
+
+            var p0 = Assert.Single(actual);
+            Assert.Equal(expected, p0);
+        }
+
+        [Fact]
+        public void SplitParameterString_SplitNoEquals_Multiple()
+        {
+            string[] expected = ["-flag1", "value1", "-flag2"];
+            string parameters = "-flag1 value1 -flag2";
+            string[] actual = BaseExecutionContext.SplitParameterString(parameters);
+            Assert.True(expected.SequenceEqual(actual));
+        }
+
+        [Fact]
+        public void SplitParameterString_SplitEquals_Multiple()
+        {
+            string[] expected = ["-flag1=value1", "-flag2"];
+            string parameters = "-flag1=value1 -flag2";
+            string[] actual = BaseExecutionContext.SplitParameterString(parameters);
+            Assert.True(expected.SequenceEqual(actual));
+        }
+
+        [Fact]
+        public void SplitParameterString_SplitNoEqualsQuotes_Multiple()
+        {
+            string[] expected = ["-flag1", "\"value1 value2\"", "-flag2"];
+            string parameters = "-flag1 \"value1 value2\" -flag2";
+            string[] actual = BaseExecutionContext.SplitParameterString(parameters);
+            Assert.True(expected.SequenceEqual(actual));
+        }
+
+        [Fact]
+        public void SplitParameterString_SplitEqualsQuotes_Multiple()
+        {
+            string[] expected = ["-flag1=\"value1 value2\"", "-flag2"];
+            string parameters = "-flag1=\"value1 value2\" -flag2";
+            string[] actual = BaseExecutionContext.SplitParameterString(parameters);
+            Assert.True(expected.SequenceEqual(actual));
+        }
+
+        #endregion
+
+        #region DoesExist
+
+        [Fact]
+        public void DoesExist_Empty_False()
+        {
+            string[] parts = [];
+            int index = 0;
+            bool actual = BaseExecutionContext.DoesExist(parts, index);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void DoesExist_Negative_False()
+        {
+            string[] parts = ["item"];
+            int index = -1;
+            bool actual = BaseExecutionContext.DoesExist(parts, index);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void DoesExist_Greater_False()
+        {
+            string[] parts = ["item"];
+            int index = 1;
+            bool actual = BaseExecutionContext.DoesExist(parts, index);
+            Assert.False(actual);
+        }
+
+        [Fact]
+        public void DoesExist_Valid_True()
+        {
+            string[] parts = ["item"];
+            int index = 0;
+            bool actual = BaseExecutionContext.DoesExist(parts, index);
+            Assert.True(actual);
+        }
+
+        #endregion
+
+        #region IsValidBool
+
+        [Theory]
+        [InlineData("", false)]
+        [InlineData("true", true)]
+        [InlineData("True", true)]
+        [InlineData("TRUE", true)]
+        [InlineData("Yes", false)]
+        [InlineData("false", true)]
+        [InlineData("False", true)]
+        [InlineData("FALSE", true)]
+        [InlineData("No", false)]
+        [InlineData("Invalid", false)]
+        public void IsValidBoolTest(string parameter, bool expected)
+        {
+            bool actual = BaseExecutionContext.IsValidBool(parameter);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region IsValidInt8
+
+        [Theory]
+        [InlineData("", null, null, false)]
+        [InlineData("", (sbyte)0, (sbyte)1, false)]
+        [InlineData("", (sbyte)0, sbyte.MaxValue, false)]
+        [InlineData("-2", null, null, true)]
+        [InlineData("-2", (sbyte)0, (sbyte)1, false)]
+        [InlineData("-2", (sbyte)0, sbyte.MaxValue, false)]
+        [InlineData("0", null, null, true)]
+        [InlineData("0", (sbyte)0, (sbyte)1, true)]
+        [InlineData("0", (sbyte)0, sbyte.MaxValue, true)]
+        [InlineData("2", null, null, true)]
+        [InlineData("2", (sbyte)0, (sbyte)1, false)]
+        [InlineData("2", (sbyte)0, sbyte.MaxValue, true)]
+        [InlineData("Invalid", null, null, false)]
+        [InlineData("Invalid", (sbyte)0, (sbyte)1, false)]
+        [InlineData("Invalid", (sbyte)0, sbyte.MaxValue, false)]
+        public void IsValidInt8Test(string parameter, sbyte? lowerBound, sbyte? upperBound, bool expected)
+        {
+            bool actual = BaseExecutionContext.IsValidInt8(parameter, lowerBound, upperBound);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region IsValidInt16
+
+        [Theory]
+        [InlineData("", null, null, false)]
+        [InlineData("", (short)0, (short)1, false)]
+        [InlineData("", (short)0, short.MaxValue, false)]
+        [InlineData("-2", null, null, true)]
+        [InlineData("-2", (short)0, (short)1, false)]
+        [InlineData("-2", (short)0, short.MaxValue, false)]
+        [InlineData("0", null, null, true)]
+        [InlineData("0", (short)0, (short)1, true)]
+        [InlineData("0", (short)0, short.MaxValue, true)]
+        [InlineData("2", null, null, true)]
+        [InlineData("2", (short)0, (short)1, false)]
+        [InlineData("2", (short)0, short.MaxValue, true)]
+        [InlineData("Invalid", null, null, false)]
+        [InlineData("Invalid", (short)0, (short)1, false)]
+        [InlineData("Invalid", (short)0, short.MaxValue, false)]
+        public void IsValidInt16Test(string parameter, short? lowerBound, short? upperBound, bool expected)
+        {
+            bool actual = BaseExecutionContext.IsValidInt16(parameter, lowerBound, upperBound);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region IsValidInt32
+
+        [Theory]
+        [InlineData("", null, null, false)]
+        [InlineData("", (int)0, (int)1, false)]
+        [InlineData("", (int)0, int.MaxValue, false)]
+        [InlineData("-2", null, null, true)]
+        [InlineData("-2", (int)0, (int)1, false)]
+        [InlineData("-2", (int)0, int.MaxValue, false)]
+        [InlineData("0", null, null, true)]
+        [InlineData("0", (int)0, (int)1, true)]
+        [InlineData("0", (int)0, int.MaxValue, true)]
+        [InlineData("2", null, null, true)]
+        [InlineData("2", (int)0, (int)1, false)]
+        [InlineData("2", (int)0, int.MaxValue, true)]
+        [InlineData("Invalid", null, null, false)]
+        [InlineData("Invalid", (int)0, (int)1, false)]
+        [InlineData("Invalid", (int)0, int.MaxValue, false)]
+        public void IsValidInt32Test(string parameter, int? lowerBound, int? upperBound, bool expected)
+        {
+            bool actual = BaseExecutionContext.IsValidInt32(parameter, lowerBound, upperBound);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region IsValidInt64
+
+        [Theory]
+        [InlineData("", null, null, false)]
+        [InlineData("", (long)0, (long)1, false)]
+        [InlineData("", (long)0, long.MaxValue, false)]
+        [InlineData("-2", null, null, true)]
+        [InlineData("-2", (long)0, (long)1, false)]
+        [InlineData("-2", (long)0, long.MaxValue, false)]
+        [InlineData("0", null, null, true)]
+        [InlineData("0", (long)0, (long)1, true)]
+        [InlineData("0", (long)0, long.MaxValue, true)]
+        [InlineData("2", null, null, true)]
+        [InlineData("2", (long)0, (long)1, false)]
+        [InlineData("2", (long)0, long.MaxValue, true)]
+        [InlineData("Invalid", null, null, false)]
+        [InlineData("Invalid", (long)0, (long)1, false)]
+        [InlineData("Invalid", (long)0, long.MaxValue, false)]
+        public void IsValidInt64Test(string parameter, long? lowerBound, long? upperBound, bool expected)
+        {
+            bool actual = BaseExecutionContext.IsValidInt64(parameter, lowerBound, upperBound);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region ExtractFactorFromValue
+
+        [Theory]
+        [InlineData("1", "1", 1)]
+        [InlineData("1c", "1", 1)]
+        [InlineData("1w", "1", 2)]
+        [InlineData("1d", "1", 4)]
+        [InlineData("1q", "1", 8)]
+        [InlineData("1k", "1", 1024)]
+        [InlineData("1M", "1", 1024 * 1024)]
+        [InlineData("1G", "1", 1024 * 1024 * 1024)]
+        public void ExtractFactorFromValueTest(string value, string expected, long expectedFactor)
+        {
+            string actual = BaseExecutionContext.ExtractFactorFromValue(value, out long factor);
+            Assert.Equal(expected, actual);
+            Assert.Equal(expectedFactor, factor);
+        }
+
+        #endregion
+
+        #region RemoveHexIdentifier
+
+        [Theory]
+        [InlineData("", "")]
+        [InlineData("0", "0")]
+        [InlineData("00", "00")]
+        [InlineData("0x", "0x")]
+        [InlineData("0X", "0X")]
+        [InlineData("A", "A")]
+        [InlineData("A0", "A0")]
+        [InlineData("Ax", "Ax")]
+        [InlineData("AX", "AX")]
+        [InlineData("012345", "012345")]
+        [InlineData("0x12345", "12345")]
+        [InlineData("0X12345", "12345")]
+        public void RemoveHexIdentifierTest(string value, string expected)
+        {
+            string actual = BaseExecutionContext.RemoveHexIdentifier(value);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts.Test/DiscImageCreatorTests.cs

@@ -0,0 +1,465 @@
+using System.Collections.Generic;
+using MPF.ExecutionContexts.DiscImageCreator;
+using SabreTools.RedumpLib.Data;
+using Xunit;
+
+namespace MPF.ExecutionContexts.Test
+{
+    public class DiscImageCreatorTests
+    {
+        // TODO: Add Converters.ToRedumpSystem test
+        // TODO: Add Converters.ToMediaType test
+
+        #region Converters.Extension
+
+        [Theory]
+        [InlineData(null, null)]
+        [InlineData(MediaType.CDROM, ".bin")]
+        [InlineData(MediaType.GDROM, ".bin")]
+        [InlineData(MediaType.Cartridge, ".bin")]
+        [InlineData(MediaType.HardDisk, ".bin")]
+        [InlineData(MediaType.CompactFlash, ".bin")]
+        [InlineData(MediaType.MMC, ".bin")]
+        [InlineData(MediaType.SDCard, ".bin")]
+        [InlineData(MediaType.FlashDrive, ".bin")]
+        [InlineData(MediaType.DVD, ".iso")]
+        [InlineData(MediaType.HDDVD, ".iso")]
+        [InlineData(MediaType.BluRay, ".iso")]
+        [InlineData(MediaType.NintendoWiiOpticalDisc, ".iso")]
+        [InlineData(MediaType.LaserDisc, ".raw")]
+        [InlineData(MediaType.NintendoGameCubeGameDisc, ".raw")]
+        [InlineData(MediaType.NintendoWiiUOpticalDisc, ".wud")]
+        [InlineData(MediaType.FloppyDisk, ".img")]
+        [InlineData(MediaType.Cassette, ".wav")]
+        [InlineData(MediaType.ApertureCard, null)]
+        public void ExtensionTest(MediaType? type, string? expected)
+        {
+            string? actual = Converters.Extension(type);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region Default Values
+
+        private static Dictionary<string, string?> AllOptions = new()
+        {
+            [SettingConstants.DVDRereadCount] = "1000",
+            [SettingConstants.MultiSectorRead] = "true",
+            [SettingConstants.MultiSectorReadValue] = "1000",
+            [SettingConstants.ParanoidMode] = "true",
+            [SettingConstants.QuietMode] = "true",
+            [SettingConstants.RereadCount] = "1000",
+            [SettingConstants.UseCMIFlag] = "true",
+        };
+
+        [Theory]
+        [InlineData(null, null, null, "filename.bin", null, null)]
+        [InlineData(RedumpSystem.AppleMacintosh, MediaType.CDROM, "/dev/sr0", "filename.bin", 2, "cd /dev/sr0 \"filename.bin\" 2 /c2 1000 /q /mr 1000 /ns /sf /ss /s 2")]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, "/dev/sr0", "filename.bin", 2, "cd /dev/sr0 \"filename.bin\" 2 /c2 1000 /q /mr 1000 /ns /sf /ss /s 2")]
+        [InlineData(RedumpSystem.AtariJaguarCDInteractiveMultimediaSystem, MediaType.CDROM, "/dev/sr0", "filename.bin", 2, "cd /dev/sr0 \"filename.bin\" 2 /aj /c2 1000 /q /mr 1000")]
+        [InlineData(RedumpSystem.HasbroVideoNow, MediaType.CDROM, "/dev/sr0", "filename.bin", 2, "cd /dev/sr0 \"filename.bin\" 2 /a 0 /c2 1000 /q /mr 1000")]
+        [InlineData(RedumpSystem.HasbroVideoNowColor, MediaType.CDROM, "/dev/sr0", "filename.bin", 2, "cd /dev/sr0 \"filename.bin\" 2 /a 0 /c2 1000 /q /mr 1000")]
+        [InlineData(RedumpSystem.HasbroVideoNowJr, MediaType.CDROM, "/dev/sr0", "filename.bin", 2, "cd /dev/sr0 \"filename.bin\" 2 /a 0 /c2 1000 /q /mr 1000")]
+        [InlineData(RedumpSystem.HasbroVideoNowXP, MediaType.CDROM, "/dev/sr0", "filename.bin", 2, "cd /dev/sr0 \"filename.bin\" 2 /a 0 /c2 1000 /q /mr 1000")]
+        [InlineData(RedumpSystem.SonyPlayStation, MediaType.CDROM, "/dev/sr0", "filename.bin", 2, "cd /dev/sr0 \"filename.bin\" 2 /c2 1000 /q /mr 1000 /nl /am")]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, "/dev/sr0", "filename.bin", 2, "dvd /dev/sr0 \"filename.bin\" 2 /c /q /rr 1000 /sf")]
+        [InlineData(RedumpSystem.MicrosoftXbox, MediaType.DVD, "/dev/sr0", "filename.bin", 2, "xbox /dev/sr0 \"filename.bin\" 2 /q /rr 1000")]
+        [InlineData(RedumpSystem.MicrosoftXbox360, MediaType.DVD, "/dev/sr0", "filename.bin", 2, "xbox /dev/sr0 \"filename.bin\" 2 /q /rr 1000")]
+        [InlineData(RedumpSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc, "/dev/sr0", "filename.bin", 2, "dvd /dev/sr0 \"filename.bin\" 2 /q /raw")]
+        [InlineData(RedumpSystem.NintendoWii, MediaType.NintendoWiiOpticalDisc, "/dev/sr0", "filename.bin", 2, "dvd /dev/sr0 \"filename.bin\" 2 /q /raw")]
+        [InlineData(RedumpSystem.SegaDreamcast, MediaType.GDROM, "/dev/sr0", "filename.bin", 2, "gd /dev/sr0 \"filename.bin\" 2 /c2 1000 /q")]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, "/dev/sr0", "filename.bin", 2, "dvd /dev/sr0 \"filename.bin\" 2 /c /q /rr 1000")]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, "/dev/sr0", "filename.bin", 2, "bd /dev/sr0 \"filename.bin\" 2 /q /rr 1000")]
+        [InlineData(RedumpSystem.NintendoWiiU, MediaType.NintendoWiiUOpticalDisc, "/dev/sr0", "filename.bin", 2, "bd /dev/sr0 \"filename.bin\" 2 /q")]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.FloppyDisk, "/dev/sr0", "filename.bin", 2, "fd /dev/sr0 \"filename.bin\"")]
+        public void DefaultValueTest(RedumpSystem? system,
+            MediaType? type,
+            string? drivePath,
+            string filename,
+            int? driveSpeed,
+            string? expected)
+        {
+            var context = new ExecutionContext(system, type, drivePath, filename, driveSpeed, AllOptions);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region Audio
+
+        [Theory]
+        [InlineData("audio F filename.bin 0 1 2 /be raw /c2 1 2 3 1 5 6 /c2new 1 /d8 /d /q /f 0 /np /nq /nr /r /am /sf 1 /ss /sk 1 0 /s 0 /t")]
+        public void AudioTest(string parameters)
+        {
+            string? expected = "audio F \"filename.bin\" 0 1 2 /be raw /c2 1 2 3 1 5 6 /c2new 1 /d8 /d /q /f 0 /np /nq /nr /r /am /sf 1 /ss /sk 1 0 /s 0 /t";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region BluRay
+
+        [Theory]
+        [InlineData("bd F filename.bin 0 /d /q /rr 0 /f 0 /ra /avdp")]
+        public void BluRayTest(string parameters)
+        {
+            string? expected = "bd F \"filename.bin\" 0 /d /q /rr 0 /f 0 /ra /avdp";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Close
+
+        [Theory]
+        [InlineData("close f")]
+        public void CloseTest(string parameters)
+        {
+            string? expected = "close f";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region CompactDisc
+
+        [Theory]
+        [InlineData("cd f filename.bin 0 /a 0 /p /aj /be raw /c2 1 2 3 1 5 6 /c2new 1 /d8 /d /q /mscf /fdesc sync edc /f 0 /fulltoc /mr 0 /np /nq /nl /ns /nr /am /sf 1 /ss /74 /s 0 /toc /trp /vn 0 /vnc /vnx")]
+        public void CompactDiscTest(string parameters)
+        {
+            string? expected = "cd f \"filename.bin\" 0 /a 0 /p /aj /be raw /c2 1 2 3 1 5 6 /c2new 1 /d8 /d /q /mscf /fdesc sync edc /f 0 /fulltoc /mr 0 /np /nq /nl /ns /nr /am /sf 1 /ss /74 /s 0 /toc /trp /vn 0 /vnc /vnx";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Data
+
+        [Theory]
+        [InlineData("data F filename.bin 0 1 2 /be raw /c2 1 2 3 1 5 6 /c2new 1 /d8 /d /q /f 0 /np /nq /nr /r /am /sf 1 /ss /sk 1 0 /s 0 /t")]
+        public void DataTest(string parameters)
+        {
+            string? expected = "data F \"filename.bin\" 0 1 2 /be raw /c2 1 2 3 1 5 6 /c2new 1 /d8 /d /q /f 0 /np /nq /nr /r /am /sf 1 /ss /sk 1 0 /s 0 /t";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region DigitalVideoDisc
+
+        [Theory]
+        [InlineData("dvd F filename.bin 0 /c /d /q /rr 0 /fix 0 /ps 0 /ra 0 1 /raw /re /r 0 1 /sf 1 /sk 1 0 /avdp")]
+        public void DigitalVideoDiscTest(string parameters)
+        {
+            string? expected = "dvd F \"filename.bin\" 0 /c /d /q /rr 0 /fix 0 /ps 0 /ra 0 1 /raw /re /r 0 1 /sf 1 /sk 1 0 /avdp";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Disk
+
+        [Theory]
+        [InlineData("disk F filename.bin /d")]
+        public void DiskTest(string parameters)
+        {
+            string? expected = "disk F \"filename.bin\" /d";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region DriveSpeed
+
+        [Theory]
+        [InlineData("ls f")]
+        public void DriveSpeedTest(string parameters)
+        {
+            string? expected = "ls f";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Eject
+
+        [Theory]
+        [InlineData("eject f")]
+        public void EjectTest(string parameters)
+        {
+            string? expected = "eject f";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Floppy
+
+        [Theory]
+        [InlineData("fd F filename.bin /d")]
+        public void FloppyTest(string parameters)
+        {
+            string? expected = "fd F \"filename.bin\" /d";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region GDROM
+
+        [Theory]
+        [InlineData("gd f filename.bin 0 /be raw /c2 1 2 3 1 5 6 /c2new 1 /d8 /d /q /f 0 /np /nq /nr /s 0")]
+        public void GDROMTest(string parameters)
+        {
+            string? expected = "gd f \"filename.bin\" 0 /be raw /c2 1 2 3 1 5 6 /c2new 1 /d8 /d /q /f 0 /np /nq /nr /s 0";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region MDS
+
+        [Theory]
+        [InlineData("mds filename.bin")]
+        public void MDSTest(string parameters)
+        {
+            string? expected = "mds \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Merge
+
+        [Theory]
+        [InlineData("merge input1.bin input2.bin")]
+        public void MergeTest(string parameters)
+        {
+            string? expected = "merge \"input1.bin\" \"input2.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Reset
+
+        [Theory]
+        [InlineData("reset f")]
+        public void ResetTest(string parameters)
+        {
+            string? expected = "reset f";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region SACD
+
+        [Theory]
+        [InlineData("sacd f filename.bin 0 /d /q")]
+        public void SACDTest(string parameters)
+        {
+            string? expected = "sacd f \"filename.bin\" 0 /d /q";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Start
+
+        [Theory]
+        [InlineData("start f")]
+        public void StartTest(string parameters)
+        {
+            string? expected = "start f";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Stop
+
+        [Theory]
+        [InlineData("stop f")]
+        public void StopTest(string parameters)
+        {
+            string? expected = "stop f";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Sub
+
+        [Theory]
+        [InlineData("sub filename.bin")]
+        public void SubTest(string parameters)
+        {
+            string? expected = "sub \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Swap
+
+        [Theory]
+        [InlineData("swap f filename.bin 0 /a 0 /be raw /c2 1 2 3 1 5 6 /c2new 1 /d8 /d /q /f 0 /np /nq /nl /ns /nr /am /sf 1 /ss /74 /s 0 /trp /vn 0 /vnc /vnx")]
+        public void SwapTest(string parameters)
+        {
+            string? expected = "swap f \"filename.bin\" 0 /a 0 /be raw /c2 1 2 3 1 5 6 /c2new 1 /d8 /d /q /f 0 /np /nq /nl /ns /nr /am /sf 1 /ss /74 /s 0 /trp /vn 0 /vnc /vnx";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Tape
+
+        [Theory]
+        [InlineData("tape filename.bin")]
+        public void TapeTest(string parameters)
+        {
+            string? expected = "tape \"filename.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Version
+
+        [Theory]
+        [InlineData("/v")]
+        public void VersionTest(string parameters)
+        {
+            string? expected = "/v";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region XBOX
+
+        [Theory]
+        [InlineData("xbox f filename.bin 0 /d /q /rr 0 /f 0 /nss 0")]
+        public void XBOXTest(string parameters)
+        {
+            string? expected = "xbox f \"filename.bin\" 0 /d /q /rr 0 /f 0 /nss 0";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region XBOXSwap
+
+        [Theory]
+        [InlineData("xboxswap f filename.bin 0 /d /q /f 0 /nss 0")]
+        public void XBOXSwapTest(string parameters)
+        {
+            string? expected = "xboxswap f \"filename.bin\" 0 /d /q /f 0 /nss 0";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region XGD2Swap
+
+        [Theory]
+        [InlineData("xgd2swap f filename.bin 0 /d /q /f 0 /nss 0")]
+        public void XGD2SwapTest(string parameters)
+        {
+            string? expected = "xgd2swap f \"filename.bin\" 0 /d /q /f 0 /nss 0";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region XGD3Swap
+
+        [Theory]
+        [InlineData("xgd3swap f filename.bin 0 /d /q /f 0 /nss 0")]
+        public void XGD3SwapTest(string parameters)
+        {
+            string? expected = "xgd3swap f \"filename.bin\" 0 /d /q /f 0 /nss 0";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts.Test/InputTests.cs

@@ -0,0 +1,410 @@
+using MPF.ExecutionContexts.Data;
+using Xunit;
+
+namespace MPF.ExecutionContexts.Test
+{
+    public class InputTests
+    {
+        #region FlagInput
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", new string[0], 0, false, false)]
+        // Invalid index
+        [InlineData("flag", new string[] { "flag" }, -1, false, false)]
+        [InlineData("flag", new string[] { "flag" }, 1, false, false)]
+        // Invalid name
+        [InlineData("flag", new string[] { "" }, 0, false, false)]
+        [InlineData("flag", new string[] { "flag2" }, 0, false, false)]
+        // Valid
+        [InlineData("flag", new string[] { "flag" }, 0, true, true)]
+        public void FlagInputTest(string name, string[] parts, int index, bool success, bool expected)
+        {
+            FlagInput input = new FlagInput(name);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region BooleanInput
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", true, new string[0], 0, false, null)]
+        // Invalid index
+        [InlineData("flag", true, new string[] { "flag" }, -1, false, null)]
+        [InlineData("flag", true, new string[] { "flag" }, 1, false, null)]
+        // Invalid name
+        [InlineData("flag", true, new string[] { "" }, 0, false, null)]
+        [InlineData("flag", true, new string[] { "flag2" }, 0, false, null)]
+        // Valid name, no following
+        [InlineData("flag", true, new string[] { "flag" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag" }, 0, true, true)]
+        // Valid name, invalid following
+        [InlineData("flag", true, new string[] { "flag", "invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag", "invalid" }, 0, true, true)]
+        [InlineData("flag", true, new string[] { "flag=invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag=invalid" }, 0, true, true)]
+        // Valid name, valid following
+        [InlineData("flag", true, new string[] { "flag", "true" }, 0, true, true)]
+        [InlineData("flag", true, new string[] { "flag", "false" }, 0, true, false)]
+        [InlineData("flag", true, new string[] { "flag=true" }, 0, true, true)]
+        [InlineData("flag", true, new string[] { "flag=false" }, 0, true, false)]
+        public void BooleanInputTest(string name, bool required, string[] parts, int index, bool success, bool? expected)
+        {
+            BooleanInput input = new BooleanInput(name, required);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region Int8Input
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", true, new string[0], 0, false, null)]
+        // Invalid index
+        [InlineData("flag", true, new string[] { "flag" }, -1, false, null)]
+        [InlineData("flag", true, new string[] { "flag" }, 1, false, null)]
+        // Invalid name
+        [InlineData("flag", true, new string[] { "" }, 0, false, null)]
+        [InlineData("flag", true, new string[] { "flag2" }, 0, false, null)]
+        // Valid name, no following
+        [InlineData("flag", true, new string[] { "flag" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag" }, 0, true, sbyte.MinValue)]
+        // Valid name, invalid following
+        [InlineData("flag", true, new string[] { "flag", "invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag", "invalid" }, 0, true, sbyte.MinValue)]
+        [InlineData("flag", true, new string[] { "flag=invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag=invalid" }, 0, true, sbyte.MinValue)]
+        // Valid name, valid following
+        [InlineData("flag", true, new string[] { "flag", "1" }, 0, true, (sbyte)1)]
+        [InlineData("flag", true, new string[] { "flag", "-1" }, 0, true, (sbyte)-1)]
+        [InlineData("flag", true, new string[] { "flag=1" }, 0, true, (sbyte)1)]
+        [InlineData("flag", true, new string[] { "flag=-1" }, 0, true, (sbyte)-1)]
+        public void Int8InputTest(string name, bool required, string[] parts, int index, bool success, sbyte? expected)
+        {
+            Int8Input input = new Int8Input(name, required);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region UInt8Input
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", true, new string[0], 0, false, null)]
+        // Invalid index
+        [InlineData("flag", true, new string[] { "flag" }, -1, false, null)]
+        [InlineData("flag", true, new string[] { "flag" }, 1, false, null)]
+        // Invalid name
+        [InlineData("flag", true, new string[] { "" }, 0, false, null)]
+        [InlineData("flag", true, new string[] { "flag2" }, 0, false, null)]
+        // Valid name, no following
+        [InlineData("flag", true, new string[] { "flag" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag" }, 0, true, byte.MinValue)]
+        // Valid name, invalid following
+        [InlineData("flag", true, new string[] { "flag", "invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag", "invalid" }, 0, true, byte.MinValue)]
+        [InlineData("flag", true, new string[] { "flag=invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag=invalid" }, 0, true, byte.MinValue)]
+        // Valid name, valid following
+        [InlineData("flag", true, new string[] { "flag", "1" }, 0, true, (byte)1)]
+        [InlineData("flag", true, new string[] { "flag=1" }, 0, true, (byte)1)]
+        public void UInt8InputTest(string name, bool required, string[] parts, int index, bool success, byte? expected)
+        {
+            UInt8Input input = new UInt8Input(name, required);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region Int16Input
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", true, new string[0], 0, false, null)]
+        // Invalid index
+        [InlineData("flag", true, new string[] { "flag" }, -1, false, null)]
+        [InlineData("flag", true, new string[] { "flag" }, 1, false, null)]
+        // Invalid name
+        [InlineData("flag", true, new string[] { "" }, 0, false, null)]
+        [InlineData("flag", true, new string[] { "flag2" }, 0, false, null)]
+        // Valid name, no following
+        [InlineData("flag", true, new string[] { "flag" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag" }, 0, true, short.MinValue)]
+        // Valid name, invalid following
+        [InlineData("flag", true, new string[] { "flag", "invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag", "invalid" }, 0, true, short.MinValue)]
+        [InlineData("flag", true, new string[] { "flag=invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag=invalid" }, 0, true, short.MinValue)]
+        // Valid name, valid following
+        [InlineData("flag", true, new string[] { "flag", "1" }, 0, true, (short)1)]
+        [InlineData("flag", true, new string[] { "flag", "-1" }, 0, true, (short)-1)]
+        [InlineData("flag", true, new string[] { "flag=1" }, 0, true, (short)1)]
+        [InlineData("flag", true, new string[] { "flag=-1" }, 0, true, (short)-1)]
+        public void Int16InputTest(string name, bool required, string[] parts, int index, bool success, short? expected)
+        {
+            Int16Input input = new Int16Input(name, required);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region UInt16Input
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", true, new string[0], 0, false, null)]
+        // Invalid index
+        [InlineData("flag", true, new string[] { "flag" }, -1, false, null)]
+        [InlineData("flag", true, new string[] { "flag" }, 1, false, null)]
+        // Invalid name
+        [InlineData("flag", true, new string[] { "" }, 0, false, null)]
+        [InlineData("flag", true, new string[] { "flag2" }, 0, false, null)]
+        // Valid name, no following
+        [InlineData("flag", true, new string[] { "flag" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag" }, 0, true, ushort.MinValue)]
+        // Valid name, invalid following
+        [InlineData("flag", true, new string[] { "flag", "invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag", "invalid" }, 0, true, ushort.MinValue)]
+        [InlineData("flag", true, new string[] { "flag=invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag=invalid" }, 0, true, ushort.MinValue)]
+        // Valid name, valid following
+        [InlineData("flag", true, new string[] { "flag", "1" }, 0, true, (ushort)1)]
+        [InlineData("flag", true, new string[] { "flag=1" }, 0, true, (ushort)1)]
+        public void UInt16InputTest(string name, bool required, string[] parts, int index, bool success, ushort? expected)
+        {
+            UInt16Input input = new UInt16Input(name, required);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region Int32Input
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", true, new string[0], 0, false, null)]
+        // Invalid index
+        [InlineData("flag", true, new string[] { "flag" }, -1, false, null)]
+        [InlineData("flag", true, new string[] { "flag" }, 1, false, null)]
+        // Invalid name
+        [InlineData("flag", true, new string[] { "" }, 0, false, null)]
+        [InlineData("flag", true, new string[] { "flag2" }, 0, false, null)]
+        // Valid name, no following
+        [InlineData("flag", true, new string[] { "flag" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag" }, 0, true, int.MinValue)]
+        // Valid name, invalid following
+        [InlineData("flag", true, new string[] { "flag", "invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag", "invalid" }, 0, true, int.MinValue)]
+        [InlineData("flag", true, new string[] { "flag=invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag=invalid" }, 0, true, int.MinValue)]
+        // Valid name, valid following
+        [InlineData("flag", true, new string[] { "flag", "1" }, 0, true, (int)1)]
+        [InlineData("flag", true, new string[] { "flag", "-1" }, 0, true, (int)-1)]
+        [InlineData("flag", true, new string[] { "flag=1" }, 0, true, (int)1)]
+        [InlineData("flag", true, new string[] { "flag=-1" }, 0, true, (int)-1)]
+        public void Int32InputTest(string name, bool required, string[] parts, int index, bool success, int? expected)
+        {
+            Int32Input input = new Int32Input(name, required);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region UInt32Input
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", true, new string[0], 0, false, null)]
+        // Invalid index
+        [InlineData("flag", true, new string[] { "flag" }, -1, false, null)]
+        [InlineData("flag", true, new string[] { "flag" }, 1, false, null)]
+        // Invalid name
+        [InlineData("flag", true, new string[] { "" }, 0, false, null)]
+        [InlineData("flag", true, new string[] { "flag2" }, 0, false, null)]
+        // Valid name, no following
+        [InlineData("flag", true, new string[] { "flag" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag" }, 0, true, uint.MinValue)]
+        // Valid name, invalid following
+        [InlineData("flag", true, new string[] { "flag", "invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag", "invalid" }, 0, true, uint.MinValue)]
+        [InlineData("flag", true, new string[] { "flag=invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag=invalid" }, 0, true, uint.MinValue)]
+        // Valid name, valid following
+        [InlineData("flag", true, new string[] { "flag", "1" }, 0, true, (uint)1)]
+        [InlineData("flag", true, new string[] { "flag=1" }, 0, true, (uint)1)]
+        public void UInt32InputTest(string name, bool required, string[] parts, int index, bool success, uint? expected)
+        {
+            UInt32Input input = new UInt32Input(name, required);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region Int64Input
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", true, new string[0], 0, false, null)]
+        // Invalid index
+        [InlineData("flag", true, new string[] { "flag" }, -1, false, null)]
+        [InlineData("flag", true, new string[] { "flag" }, 1, false, null)]
+        // Invalid name
+        [InlineData("flag", true, new string[] { "" }, 0, false, null)]
+        [InlineData("flag", true, new string[] { "flag2" }, 0, false, null)]
+        // Valid name, no following
+        [InlineData("flag", true, new string[] { "flag" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag" }, 0, true, long.MinValue)]
+        // Valid name, invalid following
+        [InlineData("flag", true, new string[] { "flag", "invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag", "invalid" }, 0, true, long.MinValue)]
+        [InlineData("flag", true, new string[] { "flag=invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag=invalid" }, 0, true, long.MinValue)]
+        // Valid name, valid following
+        [InlineData("flag", true, new string[] { "flag", "1" }, 0, true, (long)1)]
+        [InlineData("flag", true, new string[] { "flag", "-1" }, 0, true, (long)-1)]
+        [InlineData("flag", true, new string[] { "flag=1" }, 0, true, (long)1)]
+        [InlineData("flag", true, new string[] { "flag=-1" }, 0, true, (long)-1)]
+        public void Int64InputTest(string name, bool required, string[] parts, int index, bool success, long? expected)
+        {
+            Int64Input input = new Int64Input(name, required);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region UInt64Input
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", true, new string[0], 0, false, null)]
+        // Invalid index
+        [InlineData("flag", true, new string[] { "flag" }, -1, false, null)]
+        [InlineData("flag", true, new string[] { "flag" }, 1, false, null)]
+        // Invalid name
+        [InlineData("flag", true, new string[] { "" }, 0, false, null)]
+        [InlineData("flag", true, new string[] { "flag2" }, 0, false, null)]
+        // Valid name, no following
+        [InlineData("flag", true, new string[] { "flag" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag" }, 0, true, ulong.MinValue)]
+        // Valid name, invalid following
+        [InlineData("flag", true, new string[] { "flag", "invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag", "invalid" }, 0, true, ulong.MinValue)]
+        [InlineData("flag", true, new string[] { "flag=invalid" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag=invalid" }, 0, true, ulong.MinValue)]
+        // Valid name, valid following
+        [InlineData("flag", true, new string[] { "flag", "1" }, 0, true, (ulong)1)]
+        [InlineData("flag", true, new string[] { "flag=1" }, 0, true, (ulong)1)]
+        public void UInt64InputTest(string name, bool required, string[] parts, int index, bool success, ulong? expected)
+        {
+            UInt64Input input = new UInt64Input(name, required);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region StringInput
+
+        [Theory]
+        // Invalid parts
+        [InlineData("flag", true, new string[0], 0, false, null)]
+        // Invalid index
+        [InlineData("flag", true, new string[] { "flag" }, -1, false, null)]
+        [InlineData("flag", true, new string[] { "flag" }, 1, false, null)]
+        // Invalid name
+        [InlineData("flag", true, new string[] { "" }, 0, false, null)]
+        [InlineData("flag", true, new string[] { "flag2" }, 0, false, null)]
+        // Valid name, no following
+        [InlineData("flag", true, new string[] { "flag" }, 0, false, null)]
+        [InlineData("flag", false, new string[] { "flag" }, 0, true, "")]
+        // Valid name, following
+        [InlineData("flag", true, new string[] { "flag", "value" }, 0, true, "value")]
+        [InlineData("flag", true, new string[] { "flag=value" }, 0, true, "value")]
+        public void StringInputTest(string name, bool required, string[] parts, int index, bool success, string? expected)
+        {
+            StringInput input = new StringInput(name, required);
+            bool actual = input.Process(parts, ref index);
+
+            Assert.Equal(success, actual);
+            Assert.Equal(expected, input.Value);
+        }
+
+        #endregion
+
+        #region ExtractFactorFromValue
+
+        [Theory]
+        [InlineData("1", "1", 1)]
+        [InlineData("1c", "1", 1)]
+        [InlineData("1w", "1", 2)]
+        [InlineData("1d", "1", 4)]
+        [InlineData("1q", "1", 8)]
+        [InlineData("1k", "1", 1024)]
+        [InlineData("1M", "1", 1024 * 1024)]
+        [InlineData("1G", "1", 1024 * 1024 * 1024)]
+        public void ExtractFactorFromValueTest(string value, string expected, long expectedFactor)
+        {
+            string actual = Input.ExtractFactorFromValue(value, out long factor);
+            Assert.Equal(expected, actual);
+            Assert.Equal(expectedFactor, factor);
+        }
+
+        #endregion
+
+        #region RemoveHexIdentifier
+
+        [Theory]
+        [InlineData("", "")]
+        [InlineData("0", "0")]
+        [InlineData("00", "00")]
+        [InlineData("0x", "0x")]
+        [InlineData("0X", "0X")]
+        [InlineData("A", "A")]
+        [InlineData("A0", "A0")]
+        [InlineData("Ax", "Ax")]
+        [InlineData("AX", "AX")]
+        [InlineData("012345", "012345")]
+        [InlineData("0x12345", "12345")]
+        [InlineData("0X12345", "12345")]
+        public void RemoveHexIdentifierTest(string value, string expected)
+        {
+            string actual = Input.RemoveHexIdentifier(value);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts.Test/MPF.ExecutionContexts.Test.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\MPF.ExecutionContexts\MPF.ExecutionContexts.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.CodeCoverage" Version="17.14.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
+        <PackageReference Include="SabreTools.RedumpLib" Version="1.7.4" />
+        <PackageReference Include="xunit" Version="2.9.3" />
+        <PackageReference Include="xunit.abstractions" Version="2.0.3" />
+        <PackageReference Include="xunit.analyzers" Version="1.24.0" />
+        <PackageReference Include="xunit.assert" Version="2.9.3" />
+        <PackageReference Include="xunit.core" Version="2.9.3" />
+        <PackageReference Include="xunit.extensibility.core" Version="2.9.3" />
+        <PackageReference Include="xunit.extensibility.execution" Version="2.9.3" />
+        <PackageReference Include="xunit.runner.console" Version="2.9.3">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
+
+</Project>

MPF.ExecutionContexts.Test/RedumperTests.cs

@@ -0,0 +1,378 @@
+using System.Collections.Generic;
+using MPF.ExecutionContexts.Redumper;
+using SabreTools.RedumpLib.Data;
+using Xunit;
+
+namespace MPF.ExecutionContexts.Test
+{
+    public class RedumperTests
+    {
+        #region Converters.Extension
+
+        [Theory]
+        [InlineData(null, null)]
+        [InlineData(MediaType.CDROM, ".bin")]
+        [InlineData(MediaType.GDROM, ".bin")]
+        [InlineData(MediaType.DVD, ".iso")]
+        [InlineData(MediaType.HDDVD, ".iso")]
+        [InlineData(MediaType.BluRay, ".iso")]
+        [InlineData(MediaType.NintendoWiiOpticalDisc, ".iso")]
+        [InlineData(MediaType.NintendoGameCubeGameDisc, ".raw")]
+        [InlineData(MediaType.NintendoWiiUOpticalDisc, ".wud")]
+        [InlineData(MediaType.ApertureCard, null)]
+        public void ExtensionTest(MediaType? type, string? expected)
+        {
+            string? actual = Converters.Extension(type);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+    
+        #region Default Values
+
+        private static Dictionary<string, string?> AllOptions = new()
+        {
+            [SettingConstants.EnableVerbose] = "true",
+            [SettingConstants.LeadinRetryCount] = "1000",
+            [SettingConstants.ReadMethod] = "BE",
+            [SettingConstants.RereadCount] = "1000",
+            [SettingConstants.SectorOrder] = "DATA_C2_SUB",
+            [SettingConstants.DriveType] = "GENERIC",
+        };
+
+        [Theory]
+        [InlineData(null, null, null, "filename.bin", null, "disc --verbose --retries=1000 --image-name=\"filename\" --drive-type=GENERIC --drive-read-method=BE --drive-sector-order=DATA_C2_SUB --plextor-leadin-retries=1000")]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.CDROM, "/dev/sr0", "path/filename.bin", 2, "disc --verbose --skeleton --drive=/dev/sr0 --speed=2 --retries=1000 --image-path=\"path\" --image-name=\"filename\" --drive-type=GENERIC --drive-read-method=BE --drive-sector-order=DATA_C2_SUB --plextor-leadin-retries=1000")]
+        [InlineData(RedumpSystem.IBMPCcompatible, MediaType.DVD, "/dev/sr0", "path/filename.bin", 2, "disc --verbose --drive=/dev/sr0 --speed=2 --retries=1000 --image-path=\"path\" --image-name=\"filename\" --drive-type=GENERIC --drive-read-method=BE --drive-sector-order=DATA_C2_SUB --plextor-leadin-retries=1000")]
+        [InlineData(RedumpSystem.NintendoGameCube, MediaType.NintendoGameCubeGameDisc, "/dev/sr0", "path/filename.bin", 2, "disc --verbose --drive=/dev/sr0 --speed=2 --retries=1000 --image-path=\"path\" --image-name=\"filename\" --drive-type=GENERIC --drive-read-method=BE --drive-sector-order=DATA_C2_SUB --plextor-leadin-retries=1000")]
+        [InlineData(RedumpSystem.NintendoWii, MediaType.NintendoWiiOpticalDisc, "/dev/sr0", "path/filename.bin", 2, "disc --verbose --drive=/dev/sr0 --speed=2 --retries=1000 --image-path=\"path\" --image-name=\"filename\" --drive-type=GENERIC --drive-read-method=BE --drive-sector-order=DATA_C2_SUB --plextor-leadin-retries=1000")]
+        [InlineData(RedumpSystem.HDDVDVideo, MediaType.HDDVD, "/dev/sr0", "path/filename.bin", 2, "disc --verbose --drive=/dev/sr0 --speed=2 --retries=1000 --image-path=\"path\" --image-name=\"filename\" --drive-type=GENERIC --drive-read-method=BE --drive-sector-order=DATA_C2_SUB --plextor-leadin-retries=1000")]
+        [InlineData(RedumpSystem.BDVideo, MediaType.BluRay, "/dev/sr0", "path/filename.bin", 2, "disc --verbose --drive=/dev/sr0 --speed=2 --retries=1000 --image-path=\"path\" --image-name=\"filename\" --drive-type=GENERIC --drive-read-method=BE --drive-sector-order=DATA_C2_SUB --plextor-leadin-retries=1000")]
+        [InlineData(RedumpSystem.NintendoWiiU, MediaType.NintendoWiiUOpticalDisc, "/dev/sr0", "path/filename.bin", 2, "disc --verbose --drive=/dev/sr0 --speed=2 --retries=1000 --image-path=\"path\" --image-name=\"filename\" --drive-type=GENERIC --drive-read-method=BE --drive-sector-order=DATA_C2_SUB --plextor-leadin-retries=1000")]
+        public void DefaultValueTest(RedumpSystem? system,
+            MediaType? type,
+            string? drivePath,
+            string filename,
+            int? driveSpeed,
+            string? expected)
+        {
+            var context = new ExecutionContext(system, type, drivePath, filename, driveSpeed, AllOptions);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region Disc
+
+        [Theory]
+        [InlineData("disc -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("disc --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void DiscTest(string parameters)
+        {
+            string? expected = "disc --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        [Theory]
+        [InlineData("disc --drive=dr --image-path=\"directory name\" --image-name=\"image name.bin\"")]
+        public void SpacesTest(string parameters)
+        {
+            string? expected = "disc --drive=dr --image-path=\"directory name\" --image-name=\"image name.bin\"";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.True(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Rings
+
+        [Theory]
+        [InlineData("rings -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("rings --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void RingsTest(string parameters)
+        {
+            string? expected = "rings --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Dump
+
+        [Theory]
+        [InlineData("dump -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("dump --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void DumpTest(string parameters)
+        {
+            string? expected = "dump --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region DumpExtra
+
+        [Theory]
+        [InlineData("dump::extra -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("dump::extra --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void DumpExtraTest(string parameters)
+        {
+            string? expected = "dump::extra --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Refine
+
+        [Theory]
+        [InlineData("refine -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("refine --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void RefineTest(string parameters)
+        {
+            string? expected = "refine --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Verify
+
+        [Theory]
+        [InlineData("verify -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("verify --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void VerifyTest(string parameters)
+        {
+            string? expected = "verify --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region DVDKey
+
+        [Theory]
+        [InlineData("dvdkey -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("dvdkey --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void DVDKeyTest(string parameters)
+        {
+            string? expected = "dvdkey --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Eject
+
+        [Theory]
+        [InlineData("eject -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("eject --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void EjectTest(string parameters)
+        {
+            string? expected = "eject --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region DVDIsoKey
+
+        [Theory]
+        [InlineData("dvdisokey -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("dvdisokey --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void DVDIsoKeyTest(string parameters)
+        {
+            string? expected = "dvdisokey --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Protection
+
+        [Theory]
+        [InlineData("protection -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("protection --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs --disable-cdtext")]
+        public void ProtectionTest(string parameters)
+        {
+            string? expected = "protection --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Split
+
+        [Theory]
+        [InlineData("split -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("split --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void SplitTest(string parameters)
+        {
+            string? expected = "split --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Hash
+
+        [Theory]
+        [InlineData("hash -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("hash --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void HashTest(string parameters)
+        {
+            string? expected = "hash --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Info
+
+        [Theory]
+        [InlineData("info -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("info --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void InfoTest(string parameters)
+        {
+            string? expected = "info --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Skeleton
+
+        [Theory]
+        [InlineData("skeleton -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("skeleton --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void SkeletonTest(string parameters)
+        {
+            string? expected = "skeleton --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Subchannel
+
+        [Theory]
+        [InlineData("subchannel -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("subchannel --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void SubchannelTest(string parameters)
+        {
+            string? expected = "subchannel --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region Debug
+
+        [Theory]
+        [InlineData("debug -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("debug --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void DebugTest(string parameters)
+        {
+            string? expected = "debug --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+            Assert.False(context.IsDumpingCommand());
+        }
+
+        #endregion
+
+        #region FixMSF
+
+        [Theory]
+        [InlineData("fixmsf -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("fixmsf --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void FixMSFTest(string parameters)
+        {
+            string? expected = "fixmsf --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region DebugFlip
+
+        [Theory]
+        [InlineData("debug::flip -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("debug::flip --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void DebugFlipTest(string parameters)
+        {
+            string? expected = "debug::flip --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region DriveTest
+
+        [Theory]
+        [InlineData("drive::test -h --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        [InlineData("drive::test --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=path --image-name=image --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs")]
+        public void DriveTestTest(string parameters)
+        {
+            string? expected = "drive::test --help --version --verbose --auto-eject --skeleton --drive=dr --speed=8 --retries=0 --image-path=\"path\" --image-name=\"image\" --overwrite --drive-type=dt --drive-read-offset=0 --drive-c2-shift=0 --drive-pregap-start=0 --drive-read-method=drm --drive-sector-order=dso --plextor-skip-leadin --plextor-leadin-retries=0 --asus-skip-leadout --disable-cdtext --force-offset=0 --audio-silence-threshold=0 --correct-offset-shift --offset-shift-relocate --force-split --leave-unchanged --force-qtoc --skip-fill=0 --iso9660-trim --lba-start=0 --lba-end=0 --refine-subchannel --refine-sector-mode --skip=0 --dump-write-offset=0 --dump-read-size=0 --overread-leadout --force-unscrambled --legacy-subs";
+            var context = new ExecutionContext(parameters);
+            string? actual = context.GenerateParameters();
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts/Aaru/CommandStrings.cs

@@ -0,0 +1,89 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Top-level commands for Aaru
+    /// </summary>
+    public static class CommandStrings
+    {
+        public const string NONE = "";
+
+        #region Archive Family
+
+        public const string ArchivePrefixShort = "arc";
+        public const string ArchivePrefixLong = "archive";
+        public const string ArchiveInfo = "info";
+
+        #endregion
+
+        #region Database Family
+
+        public const string DatabasePrefixShort = "db";
+        public const string DatabasePrefixLong = "database";
+        public const string DatabaseStats = "stats";
+        public const string DatabaseUpdate = "update";
+
+        #endregion
+
+        #region Device Family
+
+        public const string DevicePrefixShort = "dev";
+        public const string DevicePrefixLong = "device";
+        public const string DeviceInfo = "info";
+        public const string DeviceList = "list";
+        public const string DeviceReport = "report";
+
+        #endregion
+
+        #region Filesystem Family
+
+        public const string FilesystemPrefixShort = "fi";
+        public const string FilesystemPrefixShortAlt = "fs";
+        public const string FilesystemPrefixLong = "filesystem";
+        public const string FilesystemExtract = "extract";
+        public const string FilesystemInfo = "info";
+        public const string FilesystemListShort = "ls";
+        public const string FilesystemListLong = "list";
+        public const string FilesystemOptions = "options";
+
+        #endregion
+
+        #region Image Family
+
+        public const string ImagePrefixShort = "i";
+        public const string ImagePrefixLong = "image";
+        public const string ImageChecksumShort = "chk";
+        public const string ImageChecksumLong = "checksum";
+        public const string ImageCompareShort = "cmp";
+        public const string ImageCompareLong = "compare";
+        public const string ImageConvert = "convert";
+        public const string ImageCreateSidecar = "create-sidecar";
+        public const string ImageDecode = "decode";
+        public const string ImageEntropy = "entropy";
+        public const string ImageInfo = "info";
+        public const string ImageOptions = "options";
+        public const string ImagePrint = "print";
+        public const string ImageVerify = "verify";
+
+        #endregion
+
+        #region Media Family
+
+        public const string MediaPrefixShort = "m";
+        public const string MediaPrefixLong = "media";
+        public const string MediaDump = "dump";
+        public const string MediaInfo = "info";
+        public const string MediaScan = "scan";
+
+        #endregion
+
+        #region Standalone Commands
+
+        public const string Configure = "configure";
+        public const string Formats = "formats";
+        public const string ListEncodings = "list-encodings";
+        public const string ListNamespaces = "list-namespaces";
+        public const string Remote = "remote";
+
+        #endregion
+    }
+}

MPF.ExecutionContexts/Aaru/Converters.cs

@@ -0,0 +1,22 @@
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.ExecutionContexts.Aaru
+{
+    public static class Converters
+    {
+        #region Cross-enumeration conversions
+
+        /// <summary>
+        /// Get the default extension for a given disc type
+        /// </summary>
+        /// <param name="type">MediaType value to check</param>
+        /// <returns>Valid extension (with leading '.'), null on error</returns>
+        public static string Extension(MediaType? type)
+        {
+            // Aaru has a single, unified output format by default
+            return ".aaruf";
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts/Aaru/EncodingStrings.cs

@@ -0,0 +1,43 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Supported encodings for Aaru
+    /// </summary>
+    /// TODO: Use to verify encoding settings
+    public static class EncodingStrings
+    {
+        public const string ArabicMac = "x-mac-arabic";
+        public const string AtariASCII = "atascii";
+        public const string CentralEuropeanMac = "x-mac-ce";
+        public const string CommodorePETSCII = "petscii";
+        public const string CroatianMac = "x-mac-croatian";
+        public const string CyrillicMac = "x-mac-cryillic";
+        public const string FarsiMac = "x-mac-farsi";
+        public const string GreekMac = "x-mac-greek";
+        public const string HebrewMac = "x-mac-hebrew";
+        public const string RomanianMac = "x-mac-romanian";
+        public const string SinclairZXSpectrum = "spectrum";
+        public const string SinclairZX80 = "zx80";
+        public const string SinclairZX81 = "zx81";
+        public const string TurkishMac = "x-mac-turkish";
+        public const string UkrainianMac = "x-mac-ukrainian";
+        public const string Unicode = "utf-16";
+        public const string UnicodeBigEndian = "utf-16BE";
+        public const string UnicodeUTF32BigEndian = "utf-32BE";
+        public const string UnicodeUTF32 = "utf-32";
+        public const string UnicodeUTF7 = "utf-7";
+        public const string UnicodeUTF8 = "utf-8";
+        public const string USASCII = "us-ascii";
+        public const string WesternEuropeanAppleII = "apple2";
+        public const string WesternEuropeanAppleIIc = "apple2c";
+        public const string WesternEuropeanAppleIIe = "apple2e";
+        public const string WesternEuropeanAppleIIgs = "apple2gs";
+        public const string WesternEuropeanAppleLisa = "lisa";
+        public const string WesternEuropeanAtariST = "atarist";
+        public const string WesternEuropeanGEM = "gem";
+        public const string WesternEuropeanGEOS = "geos";
+        public const string WesternEuropeanISO = "iso-8859-1";
+        public const string WesternEuropeanMac = "macintosh";
+        public const string WesternEuropeanRadix50 = "radix50";
+    }
+}

MPF.ExecutionContexts/Aaru/FlagStrings.cs

@@ -0,0 +1,173 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Dumping flags for Aaru
+    /// </summary>
+    public static class FlagStrings
+    {
+        #region Precommand Flags
+
+        public const string DebugShort = "-d";
+        public const string DebugLong = "--debug";
+        public const string HelpShort = "-h";
+        public const string HelpShortAlt = "-?";
+        public const string HelpLong = "--help";
+        public const string VerboseShort = "-v";
+        public const string VerboseLong = "--verbose";
+        public const string VersionLong = "--version";
+
+        #endregion
+
+        #region Boolean flags
+
+        public const string Adler32Short = "-a";
+        public const string Adler32Long = "--adler32";
+        public const string ClearLong = "--clear";
+        public const string ClearAllLong = "--clear-all";
+        public const string CRC16Long = "--crc16";
+        public const string CRC32Short = "-c";
+        public const string CRC32Long = "--crc32";
+        public const string CRC64Long = "--crc64";
+        public const string DiskTagsShort = "-f";
+        public const string DiskTagsLong = "--disk-tags";
+        public const string DuplicatedSectorsShort = "-p";
+        public const string DuplicatedSectorsLong = "--duplicated-sectors";
+        public const string EjectLong = "--eject";
+        public const string ExtendedAttributesShort = "-x";
+        public const string ExtendedAttributesLong = "--xattrs";
+        public const string FilesystemsShort = "-f";
+        public const string FilesystemsLong = "--filesystems";
+        public const string FirstPregapLong = "--first-pregap";
+        public const string FixOffsetLong = "--fix-offset";
+        public const string FixSubchannelLong = "--fix-subchannel";
+        public const string FixSubchannelCrcLong = "--fix-subchannel-crc";
+        public const string FixSubchannelPositionLong = "--fix-subchannel-position";
+        public const string Fletcher16Long = "--fletcher16";
+        public const string Fletcher32Long = "--fletcher32";
+        public const string ForceShort = "-f";
+        public const string ForceLong = "--force";
+        public const string GenerateSubchannelsLong = "--generate-subchannels";
+        public const string LongFormatShort = "-l";
+        public const string LongFormatLong = "--long-format";
+        public const string LongSectorsShort = "-r";
+        public const string LongSectorsLong = "--long-sectors";
+        public const string MD5Short = "-m";
+        public const string MD5Long = "--md5";
+        public const string MetadataLong = "--metadata";
+        public const string PartitionsShort = "-p";
+        public const string PartitionsLong = "--partitions";
+        public const string PauseLong = "--pause";
+        public const string PersistentLong = "--persistent";
+        public const string PrivateLong = "--private";
+        public const string ResumeShort = "-r";
+        public const string ResumeLong = "--resume";
+        public const string RetrySubchannelLong = "--retry-subchannel";
+        public const string SectorTagsShort = "-p";
+        public const string SectorTagsLong = "--sector-tags";
+        public const string SeparatedTracksShort = "-t";
+        public const string SeparatedTracksLong = "--separated-tracks";
+        public const string SHA1Short = "-s";
+        public const string SHA1Long = "--sha1";
+        public const string SHA256Long = "--sha256";
+        public const string SHA384Long = "--sha384";
+        public const string SHA512Long = "--sha512";
+        public const string SkipCdiReadyHoleLong = "--skip-cdiready-hole";
+        public const string SpamSumShort = "-f";
+        public const string SpamSumLong = "--spamsum";
+        public const string StopOnErrorShort = "-s";
+        public const string StopOnErrorLong = "--stop-on-error";
+        public const string StoreEncryptedLong = "--store-encrypted";
+        public const string TapeShort = "-t";
+        public const string TapeLong = "--tape";
+        public const string TitleKeysLong = "--title-keys";
+        public const string TrapDiscShort = "-t";
+        public const string TrapDiscLong = "--trap-disc";
+        public const string TrimLong = "--trim";
+        public const string UseBufferedReadsLong = "--use-buffered-reads";
+        public const string VerifyDiscShort = "-w";
+        public const string VerifyDiscLong = "--verify-disc";
+        public const string VerifySectorsShort = "-s";
+        public const string VerifySectorsLong = "--verify-sectors";
+        public const string WholeDiscShort = "-w";
+        public const string WholeDiscLong = "--whole-disc";
+
+        #endregion
+
+        #region Int8 flags
+
+        public const string SpeedLong = "--speed";
+
+        #endregion
+
+        #region Int16 flags
+
+        public const string RetryPassesShort = "-p";
+        public const string RetryPassesLong = "--retry-passes";
+        public const string WidthShort = "-w";
+        public const string WidthLong = "--width";
+
+        #endregion
+
+        #region Int32 flags
+
+        public const string BlockSizeShort = "-b";
+        public const string BlockSizeLong = "--block-size";
+        public const string CountShort = "-c";
+        public const string CountLong = "--count";
+        public const string MaxBlocksLong = "--max-blocks";
+        public const string MediaLastSequenceLong = "--media-lastsequence";
+        public const string MediaSequenceLong = "--media-sequence";
+        public const string SkipShort = "-k";
+        public const string SkipLong = "--skip";
+
+        #endregion
+
+        #region Int64 flags
+
+        public const string LengthShort = "-l"; // or "all"
+        public const string LengthLong = "--length"; // or "all"
+        public const string StartShort = "-s";
+        public const string StartLong = "--start";
+
+        #endregion
+
+        #region String flags
+
+        public const string CommentsLong = "--comments";
+        public const string CreatorLong = "--creator";
+        public const string DriveManufacturerLong = "--drive-manufacturer";
+        public const string DriveModelLong = "--drive-model";
+        public const string DriveRevisionLong = "--drive-revision";
+        public const string DriveSerialLong = "--drive-serial";
+        public const string EncodingShort = "-e";
+        public const string EncodingLong = "--encoding";
+        public const string FormatConvertShort = "-p";
+        public const string FormatDumpShort = "-t";
+        public const string FormatLong = "--format";
+        public const string GeometryShort = "-g";
+        public const string GeometryLong = "--geometry";
+        public const string ImgBurnLogShort = "-b";
+        public const string ImgBurnLogLong = "--ibg-log";
+        public const string MediaBarcodeLong = "--media-barcode";
+        public const string MediaManufacturerLong = "--media-manufacturer";
+        public const string MediaModelLong = "--media-model";
+        public const string MediaPartNumberLong = "--media-partnumber";
+        public const string MediaSerialLong = "--media-serial";
+        public const string MediaTitleLong = "--media-title";
+        public const string MHDDLogShort = "-m";
+        public const string MHDDLogLong = "--mhdd-log";
+        public const string NamespaceShort = "-n";
+        public const string NamespaceLong = "--namespace";
+        public const string OptionsShort = "-O";
+        public const string OptionsLong = "--options";
+        public const string OutputPrefixShort = "-w";
+        public const string OutputPrefixLong = "--output-prefix";
+        public const string ResumeFileShort = "-r";
+        public const string ResumeFileLong = "--resume-file";
+        public const string SubchannelLong = "--subchannel";
+        public const string XMLSidecarShort = "-x";
+        public const string XMLSidecarLong = "--cicm-xml";
+
+        #endregion
+    }
+}

MPF.ExecutionContexts/Aaru/FormatStrings.cs

@@ -0,0 +1,169 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Supported formats for Aaru
+    /// </summary>
+    /// TODO: Use to verify format settings
+    public static class FormatStrings
+    {
+        // Supported filters
+        public const string AppleDouble = "AppleDouble";
+        public const string AppleSingle = "AppleSingle";
+        public const string BZip2 = "BZip2";
+        public const string GZip = "GZip";
+        public const string LZip = "LZip";
+        public const string MacBinary = "MacBinary";
+        public const string NoFilter = "No filter";
+        public const string PCExchange = "PCExchange";
+        public const string XZ = "XZ";
+
+        // Read-only media image formats
+        public const string AppleDiskArchivalRetrievalTool = "Apple Disk Archival/Retrieval Tool";
+        public const string AppleNewDiskImageFormat = "Apple New Disk Image Format";
+        public const string AppleNIB = "Apple NIB";
+        public const string BlindWrite4 = "BlindWrite 4";
+        public const string BlindWrite5 = "BlindWrite 5";
+        public const string CPCEMUDiskFileAndExtendedCPCDiskFile = "CPCEMU Disk-File and Extended CPC Disk-File";
+        public const string D2FDiskImage = "d2f disk image";
+        public const string D88DiskImage = "D88 Disk Image";
+        public const string DIMDiskImage = "DIM Disk Image";
+        public const string DiscFerret = "DiscFerret";
+        public const string DiscJuggler = "DiscJuggler";
+        public const string DreamcastGDIImage = "Dreamcast GDI image";
+        public const string DunfieldsIMD = "Dunfield's IMD";
+        public const string HDCopyDiskImage = "HD-Copy disk image";
+        public const string KryoFluxSTREAM = "KryoFlux STREAM";
+        public const string MAMECompressedHunksOfData = "MAME Compressed Hunks of Data";
+        public const string MicrosoftVHDX = "Microsoft VHDX";
+        public const string NeroBurningROMImage = "Nero Burning ROM image";
+        public const string PartCloneDiskImage = "PartClone disk image";
+        public const string PartimageDiskImage = "Partimage disk image";
+        public const string SpectrumFloppyDiskImage = "Spectrum Floppy Disk Image";
+        public const string SuperCardPro = "SuperCardPro";
+        public const string SydexCopyQM = "Sydex CopyQM";
+        public const string SydexTeleDisk = "Sydex TeleDisk";
+
+        // Read/write media image formats
+        public const string AaruFormat = "Aaru Format";
+        public const string ACTApricotDiskImage = "ACT Apricot Disk Image";
+        public const string Alcohol120MediaDescriptorStructure = "Alcohol 120% Media Descriptor Structure";
+        public const string Anex86DiskImage = "Anex86 Disk Image";
+        public const string Apple2InterleavedDiskImage = "Apple ][Interleaved Disk Image";
+        public const string Apple2IMG = "Apple 2IMG";
+        public const string AppleDiskCopy42 = "Apple DiskCopy 4.2";
+        public const string AppleUniversalDiskImageFormat = "Apple Universal Disk Image Format";
+        public const string BasicLisaUtility = "Basic Lisa Utility";
+        public const string CDRDAOTocfile = "CDRDAO tocfile";
+        public const string CDRWinCuesheet = "CDRWin cuesheet";
+        public const string CisCopyDiskImageDCFile = "CisCopy Disk Image(DC-File)";
+        public const string CloneCD = "CloneCD";
+        public const string CopyTape = "CopyTape";
+        public const string DigitalResearchDiskCopy = "Digital Research DiskCopy";
+        public const string IBMSaveDskF = "IBM SaveDskF";
+        public const string MAXIDiskImage = "MAXI Disk image";
+        public const string ParallelsDiskImage = "Parallels disk image";
+        public const string QEMUCopyOnWriteDiskImage = "QEMU Copy-On-Write disk image";
+        public const string QEMUCopyOnWriteDiskImageV2 = "QEMU Copy-On-Write disk image v2";
+        public const string QEMUEnhancedDiskImage = "QEMU Enhanced Disk image";
+        public const string RawDiskImage = "Raw Disk Image";
+        public const string RayAracheliansDiskIMage = "Ray Arachelian's Disk IMage";
+        public const string RSIDEHardDiskImage = "RS-IDE Hard Disk Image";
+        public const string T98HardDiskImage = "T98 Hard Disk Image";
+        public const string T98NextNHDr0DiskImage = "T98-Next NHD r0 Disk Image";
+        public const string Virtual98DiskImage = "Virtual98 Disk Image";
+        public const string VirtualBoxDiskImage = "VirtualBox Disk Image";
+        public const string VirtualPC = "VirtualPC";
+        public const string VMwareDiskImage = "VMware disk image";
+
+        // Supported filesystems for identification and information only
+        public const string AcornAdvancedDiscFilingSystem = "Acorn Advanced Disc Filing System";
+        public const string AlexanderOsipovDOSFileSystem = "Alexander Osipov DOS file system";
+        public const string AmigaDOSFilesystem = "Amiga DOS filesystem";
+        public const string AppleFileSystem = "Apple File System";
+        public const string AppleHFSPlusFilesystem = "Apple HFS+ filesystem";
+        public const string AppleHierarchicalFileSystem = "Apple Hierarchical File System";
+        public const string AppleProDOSFilesystem = "Apple ProDOS filesystem";
+        public const string AtheOSFilesystem = "AtheOS Filesystem";
+        public const string BeFilesystem = "Be Filesystem";
+        public const string BSDFastFileSystem = "BSD Fast File System(aka UNIX File System, UFS)";
+        public const string BTreeFileSystem = "B-tree file system";
+        public const string CommodoreFileSystem = "Commodore file system";
+        public const string CramFilesystem = "Cram filesystem";
+        public const string DumpEightPlugin = "dump(8) Plugin";
+        public const string ECMA67 = "ECMA-67";
+        public const string ExtentFileSystemPlugin = "Extent File System Plugin";
+        public const string F2FSPlugin = "F2FS Plugin";
+        public const string Files11OnDiskStructure = "Files-11 On-Disk Structure";
+        public const string FossilFilesystemPlugin = "Fossil Filesystem Plugin";
+        public const string HAMMERFilesystem = "HAMMER Filesystem";
+        public const string HighPerformanceOpticalFileSystem = "High Performance Optical File System";
+        public const string HPLogicalInterchangeFormatPlugin = "HP Logical Interchange Format Plugin";
+        public const string JFSPlugin = "JFS Plugin";
+        public const string LinuxExtendedFilesystem = "Linux extended Filesystem";
+        public const string LinuxExtendedFilesystem234 = "Linux extended Filesystem 2, 3 and 4";
+        public const string LocusFilesystemPlugin = "Locus Filesystem Plugin";
+        public const string MicroDOSFileSystem = "MicroDOS file system";
+        public const string MicrosoftExtendedFileAllocationTable = "Microsoft Extended File Allocation Table";
+        public const string MinixFilesystem = "Minix Filesystem";
+        public const string NewTechnologyFileSystem = "New Technology File System(NTFS)";
+        public const string NILFS2Plugin = "NILFS2 Plugin";
+        public const string NintendoOpticalFilesystems = "Nintendo optical filesystems";
+        public const string OS2HighPerformanceFileSystem = "OS/2 High Performance File System";
+        public const string OS9RandomBlockFilePlugin = "OS-9 Random Block File Plugin";
+        public const string PCEngineCDPlugin = "PC Engine CD Plugin";
+        public const string PCFXPlugin = "PC-FX Plugin";
+        public const string ProfessionalFileSystem = "Professional File System";
+        public const string QNX4Plugin = "QNX4 Plugin";
+        public const string QNX6Plugin = "QNX6 Plugin";
+        public const string ReiserFilesystemPlugin = "Reiser Filesystem Plugin";
+        public const string Reiser4FilesystemPlugin = "Reiser4 Filesystem Plugin";
+        public const string ResilientFileSystemPlugin = "Resilient File System plugin";
+        public const string RT11FileSystem = "RT-11 file system";
+        public const string SmartFileSystem = "SmartFileSystem";
+        public const string SolarOSFilesystem = "Solar_OS filesystem";
+        public const string SquashFilesystem = "Squash filesystem";
+        public const string UNICOSFilesystemPlugin = "UNICOS Filesystem Plugin";
+        public const string UniversalDiskFormat = "Universal Disk Format";
+        public const string UNIXBootFilesystem = "UNIX Boot filesystem";
+        public const string UNIXSystemVFilesystem = "UNIX System V filesystem";
+        public const string VeritasFilesystem = "Veritas filesystem";
+        public const string VMwareFilesystem = "VMware filesystem";
+        public const string XFSFilesystemPlugin = "XFS Filesystem Plugin";
+        public const string XiaFilesystem = "Xia filesystem";
+        public const string ZFSFilesystemPlugin = "ZFS Filesystem Plugin";
+
+        // Supported filesystems that can read their contents
+        public const string AppleDOSFileSystem = "Apple DOS File System";
+        public const string AppleLisaFileSystem = "Apple Lisa File System";
+        public const string AppleMacintoshFileSystem = "Apple Macintosh File System";
+        public const string CPMFileSystem = "CP/M File System";
+        public const string FATXFilesystemPlugin = "FATX Filesystem Plugin";
+        public const string ISO9660Filesystem = "ISO9660 Filesystem";
+        public const string MicrosoftFileAllocationTable = "Microsoft File Allocation Table";
+        public const string OperaFilesystemPlugin = "Opera Filesystem Plugin";
+        public const string UCSDPascalFilesystem = "U.C.S.D.Pascal filesystem";
+
+        // Supported partitioning schemes
+        public const string AcornFileCorePartitions = "Acorn FileCore partitions";
+        public const string ACTApricotPartitions = "ACT Apricot partitions";
+        public const string AmigaRigidDiskBlock = "Amiga Rigid Disk Block";
+        public const string ApplePartitionMap = "Apple Partition Map";
+        public const string AtariPartitions = "Atari partitions";
+        public const string BSDDisklabel = "BSD disklabel";
+        public const string DECDisklabel = "DEC disklabel";
+        public const string DragonFlyBSD64bitDisklabel = "DragonFly BSD 64-bit disklabel";
+        public const string GUIDPartitionTable = "GUID Partition Table";
+        public const string Human68kPartitions = "Human 68k partitions";
+        public const string MasterBootRecord = "Master Boot Record";
+        public const string NECPC9800PartitionTable = "NEC PC-9800 partition table";
+        public const string NeXTDisklabel = "NeXT Disklabel";
+        public const string Plan9PartitionTable = "Plan9 partition table";
+        public const string RioKarmaPartitioning = "Rio Karma partitioning";
+        public const string SGIDiskVolumeHeader = "SGI Disk Volume Header";
+        public const string SunDisklabel = "Sun Disklabel";
+        public const string UNIXHardwired = "UNIX hardwired";
+        public const string UNIXVTOC = "UNIX VTOC";
+        public const string XboxPartitioning = "Xbox partitioning";
+        public const string XENIX = "XENIX";
+    }
+}

MPF.ExecutionContexts/Aaru/NamespaceStrings.cs

@@ -0,0 +1,27 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Supported namespaces for Aaru
+    /// </summary>
+    /// TODO: Use to verify namespace settings
+    public static class NamespaceStrings
+    {
+        // Namespaces for Apple Lisa File System
+        public const string LisaOfficeSystem = "office";
+        public const string LisaPascalWorkshop = "workshop"; // Default
+
+        // Namespaces for ISO9660 Filesystem
+        public const string JolietVolumeDescriptor = "joliet"; // Default
+        public const string PrimaryVolumeDescriptor = "normal";
+        public const string PrimaryVolumeDescriptorwithEncoding = "romeo";
+        public const string RockRidge = "rrip";
+        public const string PrimaryVolumeDescriptorVersionSuffix = "vms";
+
+        // Namespaces for Microsoft File Allocation Table
+        public const string DOS83UpperCase = "dos";
+        public const string LFNWhenAvailableWithFallback = "ecs"; // Default
+        public const string LongFileNames = "lfn";
+        public const string WindowsNT83MixedCase = "nt";
+        public const string OS2Extended = "os2";
+    }
+}

MPF.ExecutionContexts/Aaru/OptionStrings.cs

@@ -0,0 +1,43 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    /// <summary>
+    /// Supported options for Aaru
+    /// </summary>
+    /// TODO: Use to verify option settings
+    public static class OptionStrings
+    {
+        // Aaru format
+        public const string AaruCompress = "compress"; // boolean, default true;
+        public const string AaruDeduplicate = "deduplicate"; // boolean, default true
+        public const string AaruDictionary = "dictionary"; // number, default 33554432
+        public const string AaruMaxDDTSize = "max_ddt_size"; // number, default 256
+        public const string AaruMD5 = "md5"; // boolean, default false
+        public const string AaruSectorsPerBlock = "sectors_per_block"; // number, default 4096 [power of 2]
+        public const string AaruSHA1 = "sha1"; // boolean, default false
+        public const string AaruSHA256 = "sha256"; // boolean, default false
+        public const string AaruSpamSum = "spamsum"; // boolean, default false
+
+        // ACT Apricot Disk Image
+        public const string ACTApricotDiskImageCompress = "compress"; // boolean, default false
+
+        // Apple DiskCopy 4.2
+        public const string AppleDiskCopyMacOSX = "macosx"; // boolean, default false
+
+        // CDRDAO tocfile
+        public const string CDRDAOTocfileSeparate = "separate"; // boolean, default false
+
+        // CDRWin cuesheet
+        public const string CDRWinCuesheetSeparate = "separate"; // boolean, default false
+
+        // ISO9660 Filesystem
+        public const string ISO9660FSUseEvd = "use_evd"; // boolean, default false
+        public const string ISO9660FSUsePathTable = "use_path_table"; // boolean, default false
+        public const string ISO9660FSUseTransTbl = "use_trans_tbl"; // boolean, default false
+
+        // VMware disk image
+        public const string VMwareDiskImageAdapterType = "adapter_type"; // string, default ide [ide, lsilogic, buslogic, legacyESX]
+        public const string VMwareDiskImageHWVersion = "hwversion"; // number, default 4
+        public const string VMwareDiskImageSparse = "sparse"; // boolean, default false
+        public const string VMwareDiskImageSplit = "split"; // boolean, default false
+    }
+}

MPF.ExecutionContexts/Aaru/SettingConstants.cs

@@ -0,0 +1,20 @@
+namespace MPF.ExecutionContexts.Aaru
+{
+    public static class SettingConstants
+    {
+        public const string EnableDebug = "AaruEnableDebug";
+        public const bool EnableDebugDefault = false;
+
+        public const string EnableVerbose = "AaruEnableVerbose";
+        public const bool EnableVerboseDefault = true;
+
+        public const string ForceDumping = "AaruForceDumping";
+        public const bool ForceDumpingDefault = true;
+
+        public const string RereadCount = "AaruRereadCount";
+        public const int RereadCountDefault = 5;
+
+        public const string StripPersonalData = "AaruStripPersonalData";
+        public const bool StripPersonalDataDefault = false;
+    }
+}

MPF.ExecutionContexts/Data/BooleanInput.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents a boolean flag with an optional trailing value
+    /// </summary>
+    public class BooleanInput : Input<bool?>
+    {
+        #region Constructors
+
+        /// <inheritdoc/>
+        public BooleanInput(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public BooleanInput(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public BooleanInput(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public BooleanInput(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public BooleanInput(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public BooleanInput(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Separator
+            if (useEquals)
+                builder.Append("=");
+            else
+                builder.Append(" ");
+
+            // Value
+            builder.Append(Value.ToString());
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                // Ensure the value exists
+                if (index + 1 >= parts.Length)
+                {
+                    Value = _required ? null : true;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (!bool.TryParse(parts[index + 1], out bool value))
+                {
+                    Value = _required ? null : true;
+                    return !_required;
+                }
+
+                index++;
+                Value = value;
+                return true;
+            }
+
+            // Check for equal separated
+            if (part.StartsWith($"{Name}=") || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => part.StartsWith($"{n}=")) > -1))
+            {
+                // Split the string, using the first equal sign as the separator
+                string[] tempSplit = part.Split('=');
+                string key = tempSplit[0];
+                string val = string.Join("=", tempSplit, 1, tempSplit.Length - 1);
+
+                // Ensure the value exists
+                if (string.IsNullOrEmpty(val))
+                {
+                    Value = _required ? null : true;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (!bool.TryParse(val, out bool value))
+                {
+                    Value = _required ? null : true;
+                    return !_required;
+                }
+
+                Value = value;
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/FlagInput.cs

@@ -0,0 +1,73 @@
+using System;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents a boolean flag without a trailing value
+    /// </summary>
+    public class FlagInput : Input<bool>
+    {
+        #region Constructors
+
+        /// <inheritdoc/>
+        public FlagInput(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public FlagInput(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public FlagInput(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public FlagInput(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public FlagInput(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public FlagInput(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == false)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check the name
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                Value = true;
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/Input.cs

@@ -0,0 +1,261 @@
+using System;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents a single input for an execution context
+    /// </summary>
+    public abstract class Input
+    {
+        #region Properties
+
+        /// <summary>
+        /// Primary name for the input
+        /// </summary>
+        public readonly string Name;
+
+        /// <summary>
+        /// Alternative name for the input
+        /// </summary>
+        protected readonly string[] _altNames;
+
+        /// <summary>
+        /// Indicates if the value following is required or not
+        /// </summary>
+        protected readonly bool _required;
+
+        /// <summary>
+        /// Indicates if a value has been set
+        /// </summary>
+        public abstract bool ValueSet { get; }
+
+        #endregion
+
+        #region Constructors
+
+        /// <param name="name">Flag name / value</param>
+        public Input(string name)
+        {
+            Name = name;
+            _altNames = [];
+            _required = true;
+        }
+
+        /// <param name="name">Flag name / value</param>
+        /// <param name="required">Indicates if a following value is required</param>
+        public Input(string name, bool required)
+        {
+            Name = name;
+            _altNames = [];
+            _required = required;
+        }
+
+        /// <param name="shortName">Flag name / value</param>
+        /// <param name="longName">Verbose flag name / value</param>
+        public Input(string shortName, string longName)
+        {
+            Name = longName;
+            _altNames = [shortName];
+            _required = true;
+        }
+
+        /// <param name="shortName">Flag name / value</param>
+        /// <param name="longName">Verbose flag name / value</param>
+        /// <param name="required">Indicates if a following value is required</param>
+        public Input(string shortName, string longName, bool required)
+        {
+            Name = longName;
+            _altNames = [shortName];
+            _required = required;
+        }
+
+        /// <param name="names">Set of names to use</param>
+        public Input(string[] names)
+        {
+            Name = names.Length > 0 ? names[0] : string.Empty;
+            _altNames = names;
+            _required = true;
+        }
+
+        /// <param name="names">Set of names to use</param>
+        /// <param name="required">Indicates if a following value is required</param>
+        public Input(string[] names, bool required)
+        {
+            Name = names.Length > 0 ? names[0] : string.Empty;
+            _altNames = names;
+            _required = required;
+        }
+
+        #endregion
+
+        #region Functionality
+
+        /// <summary>
+        /// Clear any accumulated value
+        /// </summary>
+        public abstract void ClearValue();
+
+        /// <summary>
+        /// Create a formatted representation of the input and possible value
+        /// </summary>
+        /// <param name="useEquals">Use an equal sign as a separator on output</param>
+        public abstract string Format(bool useEquals);
+
+        /// <summary>
+        /// Process the current index, if possible
+        /// </summary>
+        /// <param name="parts">Parts array to be referenced</param>
+        /// <param name="index">Reference to the position in the parts</param>
+        /// <returns>True if a value could be determined, false otherwise</returns>
+        public abstract bool Process(string[] parts, ref int index);
+
+        #endregion
+
+        #region Helpers
+
+        /// <summary>
+        /// Get the trimmed value and multiplication factor from a value
+        /// </summary>
+        /// <param name="value">String value to treat as suffixed number</param>
+        /// <returns>Trimmed value and multiplication factor</returns>
+        internal static string ExtractFactorFromValue(string value, out long factor)
+        {
+            value = value.Trim('"');
+            factor = 1;
+
+            // Characters
+            if (value.EndsWith("c", StringComparison.Ordinal))
+            {
+                factor = 1;
+                value = value.TrimEnd('c');
+            }
+
+            // Words
+            else if (value.EndsWith("w", StringComparison.Ordinal))
+            {
+                factor = 2;
+                value = value.TrimEnd('w');
+            }
+
+            // Double Words
+            else if (value.EndsWith("d", StringComparison.Ordinal))
+            {
+                factor = 4;
+                value = value.TrimEnd('d');
+            }
+
+            // Quad Words
+            else if (value.EndsWith("q", StringComparison.Ordinal))
+            {
+                factor = 8;
+                value = value.TrimEnd('q');
+            }
+
+            // Kilobytes
+            else if (value.EndsWith("k", StringComparison.Ordinal))
+            {
+                factor = 1024;
+                value = value.TrimEnd('k');
+            }
+
+            // Megabytes
+            else if (value.EndsWith("M", StringComparison.Ordinal))
+            {
+                factor = 1024 * 1024;
+                value = value.TrimEnd('M');
+            }
+
+            // Gigabytes
+            else if (value.EndsWith("G", StringComparison.Ordinal))
+            {
+                factor = 1024 * 1024 * 1024;
+                value = value.TrimEnd('G');
+            }
+
+            return value;
+        }
+
+        /// <summary>
+        /// Removes a leading 0x if it exists, case insensitive
+        /// </summary>
+        /// <param name="value">String with removed leading 0x</param>
+        /// <returns></returns>
+        internal static string RemoveHexIdentifier(string value)
+        {
+            if (value.Length <= 2)
+                return value;
+            if (value[0] != '0')
+                return value;
+            if (value[1] != 'x' && value[1] != 'X')
+                return value;
+
+            return value.Substring(2);
+        }
+
+        #endregion
+    }
+
+    /// <summary>
+    /// Represents a single input for an execution context
+    /// </summary>
+    public abstract class Input<T> : Input
+    {
+        #region Properties
+
+        /// <summary>
+        /// Represents the last value stored
+        /// </summary>
+        public T? Value { get; protected set; }
+
+        /// <inheritdoc/>
+        public override bool ValueSet => Value != null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public Input(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public Input(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public Input(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public Input(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public Input(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public Input(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        #region Functionality
+
+        /// <inheritdoc/>
+        public override void ClearValue()
+        {
+            Value = default;
+        }
+
+        /// <summary>
+        /// Set a new value
+        /// </summary>
+        public void SetValue(T value)
+        {
+            Value = value;
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts/Data/Int16Input.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents an Int16 flag with an optional trailing value
+    /// </summary>
+    public class Int16Input : Input<short?>
+    {
+        #region Properties
+
+        /// <summary>
+        /// Indicates a minimum value (inclusive) for the flag
+        /// </summary>
+        public short? MinValue { get; set; } = null;
+
+        /// <summary>
+        /// Indicates a maximum value (inclusive) for the flag
+        /// </summary>
+        public short? MaxValue { get; set; } = null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public Int16Input(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public Int16Input(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public Int16Input(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public Int16Input(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public Int16Input(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public Int16Input(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Only output separator and value if needed
+            if (_required || (!_required && Value != short.MinValue))
+            {
+                // Separator
+                if (useEquals)
+                    builder.Append("=");
+                else
+                    builder.Append(" ");
+
+                // Value
+                builder.Append(Value.ToString());
+            }
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                // Ensure the value exists
+                if (index + 1 >= parts.Length)
+                {
+                    Value = _required ? null : short.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(parts[index + 1], out short? value) && value != null)
+                {
+                    index++;
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : short.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            // Check for equal separated
+            if (part.StartsWith($"{Name}=") || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => part.StartsWith($"{n}=")) > -1))
+            {
+                // Split the string, using the first equal sign as the separator
+                string[] tempSplit = part.Split('=');
+                string key = tempSplit[0];
+                string val = string.Join("=", tempSplit, 1, tempSplit.Length - 1);
+
+                // Ensure the value exists
+                if (string.IsNullOrEmpty(val))
+                {
+                    Value = _required ? null : short.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(val, out short? value) && value != null)
+                {
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : short.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parse a value from a string
+        /// </summary>
+        private static bool ParseValue(string str, out short? output)
+        {
+            // If the next value is valid
+            if (short.TryParse(str, out short value))
+            {
+                output = value;
+                return true;
+            }
+
+            // Try to process as a formatted string
+            string baseVal = ExtractFactorFromValue(str, out long factor);
+            if (short.TryParse(baseVal, out value))
+            {
+                output = (short)(value * factor);
+                return true;
+            }
+
+            // Try to process as a hex string
+            string hexValue = RemoveHexIdentifier(baseVal);
+            if (short.TryParse(hexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out value))
+            {
+                output = (short)(value * factor);
+                return true;
+            }
+
+            // The value could not be parsed
+            output = null;
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/Int32ArrInput.cs

@@ -0,0 +1,161 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents an Int32 flag with an optional trailing value
+    /// </summary>
+    public class Int32ArrInput : Input<int?[]>
+    {
+        #region Properties
+
+        /// <summary>
+        /// Internal array size
+        /// </summary>
+        public int Size { get; set; }
+
+        /// <summary>
+        /// Indicates a minimum value (inclusive) for the flag
+        /// </summary>
+        public int? MinValue { get; set; } = null;
+
+        /// <summary>
+        /// Indicates a maximum value (inclusive) for the flag
+        /// </summary>
+        public int? MaxValue { get; set; } = null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public Int32ArrInput(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public Int32ArrInput(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public Int32ArrInput(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public Int32ArrInput(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public Int32ArrInput(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public Int32ArrInput(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Only output separator and value if needed
+            if (_required || (!_required && Value != null))
+            {
+                // Separator
+                if (useEquals)
+                    builder.Append("=");
+                else
+                    builder.Append(" ");
+
+                // Value
+                int?[] nonNull = Array.FindAll(Value, i => i != null);
+                string[] stringValues = Array.ConvertAll(nonNull, i => i.ToString() ?? string.Empty);
+                builder.Append(string.Join(" ", stringValues));
+            }
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                Value = new int?[Size];
+                for (int i = 0; i < Size; i++)
+                {
+                    // Ensure the value exists
+                    if (index + 1 >= parts.Length)
+                        return !_required;
+
+                    // If the next value is valid
+                    if (ParseValue(parts[index + 1], out int? value) && value != null)
+                    {
+                        index++;
+                        Value[i] = value;
+                        Value[i] = (MinValue != null && Value[i] < MinValue) ? MinValue : Value[i];
+                        Value[i] = (MaxValue != null && Value[i] > MaxValue) ? MaxValue : Value[i];
+                        continue;
+                    }
+
+                    // Return value based on required flag
+                    return !_required;
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parse a value from a string
+        /// </summary>
+        private static bool ParseValue(string str, out int? output)
+        {
+            // If the next value is valid
+            if (int.TryParse(str, out int value))
+            {
+                output = value;
+                return true;
+            }
+
+            // Try to process as a formatted string
+            string baseVal = ExtractFactorFromValue(str, out long factor);
+            if (int.TryParse(baseVal, out value))
+            {
+                output = (int)(value * factor);
+                return true;
+            }
+
+            // Try to process as a hex string
+            string hexValue = RemoveHexIdentifier(baseVal);
+            if (int.TryParse(hexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out value))
+            {
+                output = (int)(value * factor);
+                return true;
+            }
+
+            // The value could not be parsed
+            output = null;
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/Int32Input.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents an Int32 flag with an optional trailing value
+    /// </summary>
+    public class Int32Input : Input<int?>
+    {
+        #region Properties
+
+        /// <summary>
+        /// Indicates a minimum value (inclusive) for the flag
+        /// </summary>
+        public int? MinValue { get; set; } = null;
+
+        /// <summary>
+        /// Indicates a maximum value (inclusive) for the flag
+        /// </summary>
+        public int? MaxValue { get; set; } = null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public Int32Input(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public Int32Input(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public Int32Input(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public Int32Input(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public Int32Input(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public Int32Input(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Only output separator and value if needed
+            if (_required || (!_required && Value != int.MinValue))
+            {
+                // Separator
+                if (useEquals)
+                    builder.Append("=");
+                else
+                    builder.Append(" ");
+
+                // Value
+                builder.Append(Value.ToString());
+            }
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                // Ensure the value exists
+                if (index + 1 >= parts.Length)
+                {
+                    Value = _required ? null : int.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(parts[index + 1], out int? value) && value != null)
+                {
+                    index++;
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : int.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            // Check for equal separated
+            if (part.StartsWith($"{Name}=") || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => part.StartsWith($"{n}=")) > -1))
+            {
+                // Split the string, using the first equal sign as the separator
+                string[] tempSplit = part.Split('=');
+                string key = tempSplit[0];
+                string val = string.Join("=", tempSplit, 1, tempSplit.Length - 1);
+
+                // Ensure the value exists
+                if (string.IsNullOrEmpty(val))
+                {
+                    Value = _required ? null : int.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(val, out int? value) && value != null)
+                {
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : int.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parse a value from a string
+        /// </summary>
+        private static bool ParseValue(string str, out int? output)
+        {
+            // If the next value is valid
+            if (int.TryParse(str, out int value))
+            {
+                output = value;
+                return true;
+            }
+
+            // Try to process as a formatted string
+            string baseVal = ExtractFactorFromValue(str, out long factor);
+            if (int.TryParse(baseVal, out value))
+            {
+                output = (int)(value * factor);
+                return true;
+            }
+
+            // Try to process as a hex string
+            string hexValue = RemoveHexIdentifier(baseVal);
+            if (int.TryParse(hexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out value))
+            {
+                output = (int)(value * factor);
+                return true;
+            }
+
+            // The value could not be parsed
+            output = null;
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/Int64Input.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents an Int64 flag with an optional trailing value
+    /// </summary>
+    public class Int64Input : Input<long?>
+    {
+        #region Properties
+
+        /// <summary>
+        /// Indicates a minimum value (inclusive) for the flag
+        /// </summary>
+        public long? MinValue { get; set; } = null;
+
+        /// <summary>
+        /// Indicates a maximum value (inclusive) for the flag
+        /// </summary>
+        public long? MaxValue { get; set; } = null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public Int64Input(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public Int64Input(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public Int64Input(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public Int64Input(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public Int64Input(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public Int64Input(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Only output separator and value if needed
+            if (_required || (!_required && Value != long.MinValue))
+            {
+                // Separator
+                if (useEquals)
+                    builder.Append("=");
+                else
+                    builder.Append(" ");
+
+                // Value
+                builder.Append(Value.ToString());
+            }
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                // Ensure the value exists
+                if (index + 1 >= parts.Length)
+                {
+                    Value = _required ? null : long.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(parts[index + 1], out long? value) && value != null)
+                {
+                    index++;
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : long.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            // Check for equal separated
+            if (part.StartsWith($"{Name}=") || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => part.StartsWith($"{n}=")) > -1))
+            {
+                // Split the string, using the first equal sign as the separator
+                string[] tempSplit = part.Split('=');
+                string key = tempSplit[0];
+                string val = string.Join("=", tempSplit, 1, tempSplit.Length - 1);
+
+                // Ensure the value exists
+                if (string.IsNullOrEmpty(val))
+                {
+                    Value = _required ? null : long.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(val, out long? value) && value != null)
+                {
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : long.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parse a value from a string
+        /// </summary>
+        private static bool ParseValue(string str, out long? output)
+        {
+            // If the next value is valid
+            if (long.TryParse(str, out long value))
+            {
+                output = value;
+                return true;
+            }
+
+            // Try to process as a formatted string
+            string baseVal = ExtractFactorFromValue(str, out long factor);
+            if (long.TryParse(baseVal, out value))
+            {
+                output = (long)(value * factor);
+                return true;
+            }
+
+            // Try to process as a hex string
+            string hexValue = RemoveHexIdentifier(baseVal);
+            if (long.TryParse(hexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out value))
+            {
+                output = (long)(value * factor);
+                return true;
+            }
+
+            // The value could not be parsed
+            output = null;
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/Int8Input.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents an Int8 flag with an optional trailing value
+    /// </summary>
+    public class Int8Input : Input<sbyte?>
+    {
+        #region Properties
+
+        /// <summary>
+        /// Indicates a minimum value (inclusive) for the flag
+        /// </summary>
+        public sbyte? MinValue { get; set; } = null;
+
+        /// <summary>
+        /// Indicates a maximum value (inclusive) for the flag
+        /// </summary>
+        public sbyte? MaxValue { get; set; } = null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public Int8Input(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public Int8Input(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public Int8Input(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public Int8Input(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public Int8Input(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public Int8Input(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Only output separator and value if needed
+            if (_required || (!_required && Value != sbyte.MinValue))
+            {
+                // Separator
+                if (useEquals)
+                    builder.Append("=");
+                else
+                    builder.Append(" ");
+
+                // Value
+                builder.Append(Value.ToString());
+            }
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                // Ensure the value exists
+                if (index + 1 >= parts.Length)
+                {
+                    Value = _required ? null : sbyte.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(parts[index + 1], out sbyte? value) && value != null)
+                {
+                    index++;
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : sbyte.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            // Check for equal separated
+            if (part.StartsWith($"{Name}=") || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => part.StartsWith($"{n}=")) > -1))
+            {
+                // Split the string, using the first equal sign as the separator
+                string[] tempSplit = part.Split('=');
+                string key = tempSplit[0];
+                string val = string.Join("=", tempSplit, 1, tempSplit.Length - 1);
+
+                // Ensure the value exists
+                if (string.IsNullOrEmpty(val))
+                {
+                    Value = _required ? null : sbyte.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(val, out sbyte? value) && value != null)
+                {
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : sbyte.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parse a value from a string
+        /// </summary>
+        private static bool ParseValue(string str, out sbyte? output)
+        {
+            // If the next value is valid
+            if (sbyte.TryParse(str, out sbyte value))
+            {
+                output = value;
+                return true;
+            }
+
+            // Try to process as a formatted string
+            string baseVal = ExtractFactorFromValue(str, out long factor);
+            if (sbyte.TryParse(baseVal, out value))
+            {
+                output = (sbyte)(value * factor);
+                return true;
+            }
+
+            // Try to process as a hex string
+            string hexValue = RemoveHexIdentifier(baseVal);
+            if (sbyte.TryParse(hexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out value))
+            {
+                output = (sbyte)(value * factor);
+                return true;
+            }
+
+            // The value could not be parsed
+            output = null;
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/StringInput.cs

@@ -0,0 +1,126 @@
+using System;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents a string flag with an optional trailing value
+    /// </summary>
+    public class StringInput : Input<string>
+
+    {
+        #region Properties
+
+        /// <summary>
+        /// Indicates whether quotes are used in output or not
+        /// </summary>
+        public bool Quotes { get; set; } = false;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public StringInput(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public StringInput(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public StringInput(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public StringInput(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public StringInput(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public StringInput(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Only output separator and value if needed
+            if (_required || (!_required && Value != string.Empty))
+            {
+                // Separator
+                if (useEquals)
+                    builder.Append("=");
+                else
+                    builder.Append(" ");
+
+                // Value
+                if (Quotes)
+                    builder.Append($"\"{Value}\"");
+                else
+                    builder.Append(Value);
+            }
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                // Ensure the value exists
+                if (index + 1 >= parts.Length)
+                {
+                    Value = _required ? null : string.Empty;
+                    return !_required;
+                }
+
+                index++;
+                Value = parts[index].Trim('"');
+                return true;
+            }
+
+            // Check for equal separated
+            if (part.StartsWith($"{Name}=") || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => part.StartsWith($"{n}=")) > -1))
+            {
+                // Split the string, using the first equal sign as the separator
+                string[] tempSplit = part.Split('=');
+                string key = tempSplit[0];
+                string val = string.Join("=", tempSplit, 1, tempSplit.Length - 1);
+
+                // Ensure the value exists
+                if (string.IsNullOrEmpty(val))
+                {
+                    Value = _required ? null : string.Empty;
+                    return !_required;
+                }
+
+                Value = val.Trim('"');
+                return true;
+            }
+
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/UInt16Input.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents an UInt16 flag with an optional trailing value
+    /// </summary>
+    public class UInt16Input : Input<ushort?>
+    {
+        #region Properties
+
+        /// <summary>
+        /// Indicates a minimum value (inclusive) for the flag
+        /// </summary>
+        public ushort? MinValue { get; set; } = null;
+
+        /// <summary>
+        /// Indicates a maximum value (inclusive) for the flag
+        /// </summary>
+        public ushort? MaxValue { get; set; } = null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public UInt16Input(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public UInt16Input(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public UInt16Input(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public UInt16Input(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public UInt16Input(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public UInt16Input(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Only output separator and value if needed
+            if (_required || (!_required && Value != ushort.MinValue))
+            {
+                // Separator
+                if (useEquals)
+                    builder.Append("=");
+                else
+                    builder.Append(" ");
+
+                // Value
+                builder.Append(Value.ToString());
+            }
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                // Ensure the value exists
+                if (index + 1 >= parts.Length)
+                {
+                    Value = _required ? null : ushort.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(parts[index + 1], out ushort? value) && value != null)
+                {
+                    index++;
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : ushort.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            // Check for equal separated
+            if (part.StartsWith($"{Name}=") || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => part.StartsWith($"{n}=")) > -1))
+            {
+                // Split the string, using the first equal sign as the separator
+                string[] tempSplit = part.Split('=');
+                string key = tempSplit[0];
+                string val = string.Join("=", tempSplit, 1, tempSplit.Length - 1);
+
+                // Ensure the value exists
+                if (string.IsNullOrEmpty(val))
+                {
+                    Value = _required ? null : ushort.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(val, out ushort? value) && value != null)
+                {
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : ushort.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parse a value from a string
+        /// </summary>
+        private static bool ParseValue(string str, out ushort? output)
+        {
+            // If the next value is valid
+            if (ushort.TryParse(str, out ushort value))
+            {
+                output = value;
+                return true;
+            }
+
+            // Try to process as a formatted string
+            string baseVal = ExtractFactorFromValue(str, out long factor);
+            if (ushort.TryParse(baseVal, out value))
+            {
+                output = (ushort)(value * factor);
+                return true;
+            }
+
+            // Try to process as a hex string
+            string hexValue = RemoveHexIdentifier(baseVal);
+            if (ushort.TryParse(hexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out value))
+            {
+                output = (ushort)(value * factor);
+                return true;
+            }
+
+            // The value could not be parsed
+            output = null;
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/UInt32Input.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents an UInt32 flag with an optional trailing value
+    /// </summary>
+    public class UInt32Input : Input<uint?>
+    {
+        #region Properties
+
+        /// <summary>
+        /// Indicates a minimum value (inclusive) for the flag
+        /// </summary>
+        public uint? MinValue { get; set; } = null;
+
+        /// <summary>
+        /// Indicates a maximum value (inclusive) for the flag
+        /// </summary>
+        public uint? MaxValue { get; set; } = null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public UInt32Input(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public UInt32Input(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public UInt32Input(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public UInt32Input(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public UInt32Input(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public UInt32Input(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Only output separator and value if needed
+            if (_required || (!_required && Value != uint.MinValue))
+            {
+                // Separator
+                if (useEquals)
+                    builder.Append("=");
+                else
+                    builder.Append(" ");
+
+                // Value
+                builder.Append(Value.ToString());
+            }
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                // Ensure the value exists
+                if (index + 1 >= parts.Length)
+                {
+                    Value = _required ? null : uint.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(parts[index + 1], out uint? value) && value != null)
+                {
+                    index++;
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : uint.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            // Check for equal separated
+            if (part.StartsWith($"{Name}=") || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => part.StartsWith($"{n}=")) > -1))
+            {
+                // Split the string, using the first equal sign as the separator
+                string[] tempSplit = part.Split('=');
+                string key = tempSplit[0];
+                string val = string.Join("=", tempSplit, 1, tempSplit.Length - 1);
+
+                // Ensure the value exists
+                if (string.IsNullOrEmpty(val))
+                {
+                    Value = _required ? null : uint.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(val, out uint? value) && value != null)
+                {
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : uint.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parse a value from a string
+        /// </summary>
+        private static bool ParseValue(string str, out uint? output)
+        {
+            // If the next value is valid
+            if (uint.TryParse(str, out uint value))
+            {
+                output = value;
+                return true;
+            }
+
+            // Try to process as a formatted string
+            string baseVal = ExtractFactorFromValue(str, out long factor);
+            if (uint.TryParse(baseVal, out value))
+            {
+                output = (uint)(value * factor);
+                return true;
+            }
+
+            // Try to process as a hex string
+            string hexValue = RemoveHexIdentifier(baseVal);
+            if (uint.TryParse(hexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out value))
+            {
+                output = (uint)(value * factor);
+                return true;
+            }
+
+            // The value could not be parsed
+            output = null;
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/UInt64Input.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents an UInt64 flag with an optional trailing value
+    /// </summary>
+    public class UInt64Input : Input<ulong?>
+    {
+        #region Properties
+
+        /// <summary>
+        /// Indicates a minimum value (inclusive) for the flag
+        /// </summary>
+        public ulong? MinValue { get; set; } = null;
+
+        /// <summary>
+        /// Indicates a maximum value (inclusive) for the flag
+        /// </summary>
+        public ulong? MaxValue { get; set; } = null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public UInt64Input(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public UInt64Input(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public UInt64Input(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public UInt64Input(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public UInt64Input(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public UInt64Input(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Only output separator and value if needed
+            if (_required || (!_required && Value != ulong.MinValue))
+            {
+                // Separator
+                if (useEquals)
+                    builder.Append("=");
+                else
+                    builder.Append(" ");
+
+                // Value
+                builder.Append(Value.ToString());
+            }
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                // Ensure the value exists
+                if (index + 1 >= parts.Length)
+                {
+                    Value = _required ? null : ulong.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(parts[index + 1], out ulong? value) && value != null)
+                {
+                    index++;
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : ulong.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            // Check for equal separated
+            if (part.StartsWith($"{Name}=") || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => part.StartsWith($"{n}=")) > -1))
+            {
+                // Split the string, using the first equal sign as the separator
+                string[] tempSplit = part.Split('=');
+                string key = tempSplit[0];
+                string val = string.Join("=", tempSplit, 1, tempSplit.Length - 1);
+
+                // Ensure the value exists
+                if (string.IsNullOrEmpty(val))
+                {
+                    Value = _required ? null : ulong.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(val, out ulong? value) && value != null)
+                {
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : ulong.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parse a value from a string
+        /// </summary>
+        private static bool ParseValue(string str, out ulong? output)
+        {
+            // If the next value is valid
+            if (ulong.TryParse(str, out ulong value))
+            {
+                output = value;
+                return true;
+            }
+
+            // Try to process as a formatted string
+            string baseVal = ExtractFactorFromValue(str, out long factor);
+            if (ulong.TryParse(baseVal, out value))
+            {
+                output = (ulong)(value * (ulong)factor);
+                return true;
+            }
+
+            // Try to process as a hex string
+            string hexValue = RemoveHexIdentifier(baseVal);
+            if (ulong.TryParse(hexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out value))
+            {
+                output = (ulong)(value * (ulong)factor);
+                return true;
+            }
+
+            // The value could not be parsed
+            output = null;
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/Data/UInt8Input.cs

@@ -0,0 +1,189 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace MPF.ExecutionContexts.Data
+{
+    /// <summary>
+    /// Represents an UInt8 flag with an optional trailing value
+    /// </summary>
+    public class UInt8Input : Input<byte?>
+    {
+        #region Properties
+
+        /// <summary>
+        /// Indicates a minimum value (inclusive) for the flag
+        /// </summary>
+        public byte? MinValue { get; set; } = null;
+
+        /// <summary>
+        /// Indicates a maximum value (inclusive) for the flag
+        /// </summary>
+        public byte? MaxValue { get; set; } = null;
+
+        #endregion
+
+        #region Constructors
+
+        /// <inheritdoc/>
+        public UInt8Input(string name)
+            : base(name) { }
+
+        /// <inheritdoc/>
+        public UInt8Input(string name, bool required)
+            : base(name, required) { }
+
+        /// <inheritdoc/>
+        public UInt8Input(string shortName, string longName)
+            : base(shortName, longName) { }
+
+        /// <inheritdoc/>
+        public UInt8Input(string shortName, string longName, bool required)
+            : base(shortName, longName, required) { }
+
+        /// <inheritdoc/>
+        public UInt8Input(string[] names)
+            : base(names) { }
+
+        /// <inheritdoc/>
+        public UInt8Input(string[] names, bool required)
+            : base(names, required) { }
+
+        #endregion
+
+        /// <inheritdoc/>
+        public override string Format(bool useEquals)
+        {
+            // Do not output if there is no value
+            if (Value == null)
+                return string.Empty;
+
+            // Build the output format
+            var builder = new StringBuilder();
+
+            // Flag name
+            builder.Append(Name);
+
+            // Only output separator and value if needed
+            if (_required || (!_required && Value != byte.MinValue))
+            {
+                // Separator
+                if (useEquals)
+                    builder.Append("=");
+                else
+                    builder.Append(" ");
+
+                // Value
+                builder.Append(Value.ToString());
+            }
+
+            return builder.ToString();
+        }
+
+        /// <inheritdoc/>
+        public override bool Process(string[] parts, ref int index)
+        {
+            // Check the parts array
+            if (index < 0 || index >= parts.Length)
+                return false;
+
+            // Check for space-separated
+            string part = parts[index];
+            if (part == Name || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => n == part) > -1))
+            {
+                // Ensure the value exists
+                if (index + 1 >= parts.Length)
+                {
+                    Value = _required ? null : byte.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(parts[index + 1], out byte? value) && value != null)
+                {
+                    index++;
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : byte.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            // Check for equal separated
+            if (part.StartsWith($"{Name}=") || (_altNames.Length > 0 && Array.FindIndex(_altNames, n => part.StartsWith($"{n}=")) > -1))
+            {
+                // Split the string, using the first equal sign as the separator
+                string[] tempSplit = part.Split('=');
+                string key = tempSplit[0];
+                string val = string.Join("=", tempSplit, 1, tempSplit.Length - 1);
+
+                // Ensure the value exists
+                if (string.IsNullOrEmpty(val))
+                {
+                    Value = _required ? null : byte.MinValue;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return !_required;
+                }
+
+                // If the next value is valid
+                if (ParseValue(val, out byte? value) && value != null)
+                {
+                    Value = value;
+                    Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                    Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                    return true;
+                }
+
+                // Return value based on required flag
+                Value = _required ? null : byte.MinValue;
+                Value = (MinValue != null && Value < MinValue) ? MinValue : Value;
+                Value = (MaxValue != null && Value > MaxValue) ? MaxValue : Value;
+                return !_required;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parse a value from a string
+        /// </summary>
+        private static bool ParseValue(string str, out byte? output)
+        {
+            // If the next value is valid
+            if (byte.TryParse(str, out byte value))
+            {
+                output = value;
+                return true;
+            }
+
+            // Try to process as a formatted string
+            string baseVal = ExtractFactorFromValue(str, out long factor);
+            if (byte.TryParse(baseVal, out value))
+            {
+                output = (byte)(value * factor);
+                return true;
+            }
+
+            // Try to process as a hex string
+            string hexValue = RemoveHexIdentifier(baseVal);
+            if (byte.TryParse(hexValue, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out value))
+            {
+                output = (byte)(value * factor);
+                return true;
+            }
+
+            // The value could not be parsed
+            output = null;
+            return false;
+        }
+    }
+}

MPF.ExecutionContexts/DiscImageCreator/CommandStrings.cs

@@ -0,0 +1,35 @@
+namespace MPF.ExecutionContexts.DiscImageCreator
+{
+    /// <summary>
+    /// Top-level commands for DiscImageCreator
+    /// </summary>
+    public static class CommandStrings
+    {
+        public const string NONE = "";
+        public const string Audio = "audio";
+        public const string BluRay = "bd";
+        public const string Close = "close";
+        public const string CompactDisc = "cd";
+        public const string Data = "data";
+        public const string DigitalVideoDisc = "dvd";
+        public const string Disk = "disk";
+        public const string DriveSpeed = "ls";
+        public const string Eject = "eject";
+        public const string Floppy = "fd";
+        public const string GDROM = "gd";
+        public const string MDS = "mds";
+        public const string Merge = "merge";
+        public const string Reset = "reset";
+        public const string SACD = "sacd";
+        public const string Start = "start";
+        public const string Stop = "stop";
+        public const string Sub = "sub";
+        public const string Swap = "swap";
+        public const string Tape = "tape";
+        public const string Version = "/v";
+        public const string XBOX = "xbox";
+        public const string XBOXSwap = "xboxswap";
+        public const string XGD2Swap = "xgd2swap";
+        public const string XGD3Swap = "xgd3swap";
+    }
+}

MPF.ExecutionContexts/DiscImageCreator/Converters.cs

@@ -0,0 +1,100 @@
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.ExecutionContexts.DiscImageCreator
+{
+    public static class Converters
+    {
+        #region Cross-enumeration conversions
+
+        /// <summary>
+        /// Get the most common known system for a given MediaType
+        /// </summary>
+        /// <param name="baseCommand">Command value to check</param>
+        /// <returns>RedumpSystem if possible, null on error</returns>
+        public static RedumpSystem? ToRedumpSystem(string baseCommand)
+        {
+            return baseCommand switch
+            {
+                CommandStrings.Audio => (RedumpSystem?)RedumpSystem.AudioCD,
+                CommandStrings.CompactDisc
+                    or CommandStrings.Data
+                    or CommandStrings.DigitalVideoDisc
+                    or CommandStrings.Disk
+                    or CommandStrings.Floppy
+                    or CommandStrings.Tape => (RedumpSystem?)RedumpSystem.IBMPCcompatible,
+                CommandStrings.GDROM
+                    or CommandStrings.Swap => (RedumpSystem?)RedumpSystem.SegaDreamcast,
+                CommandStrings.BluRay => (RedumpSystem?)RedumpSystem.SonyPlayStation3,
+                CommandStrings.SACD => (RedumpSystem?)RedumpSystem.SuperAudioCD,
+                CommandStrings.XBOX
+                    or CommandStrings.XBOXSwap => (RedumpSystem?)RedumpSystem.MicrosoftXbox,
+                CommandStrings.XGD2Swap
+                    or CommandStrings.XGD3Swap => (RedumpSystem?)RedumpSystem.MicrosoftXbox360,
+                _ => null,
+            };
+        }
+
+        /// <summary>
+        /// Get the MediaType associated with a given base command
+        /// </summary>
+        /// <param name="baseCommand">Command value to check</param>
+        /// <returns>MediaType if possible, null on error</returns>
+        /// <remarks>This takes the "safe" route by assuming the larger of any given format</remarks>
+        public static MediaType? ToMediaType(string? baseCommand)
+        {
+            return baseCommand switch
+            {
+                CommandStrings.Audio
+                    or CommandStrings.CompactDisc
+                    or CommandStrings.Data
+                    or CommandStrings.SACD => (MediaType?)MediaType.CDROM,
+                CommandStrings.GDROM
+                    or CommandStrings.Swap => (MediaType?)MediaType.GDROM,
+                CommandStrings.DigitalVideoDisc
+                    or CommandStrings.XBOX
+                    or CommandStrings.XBOXSwap
+                    or CommandStrings.XGD2Swap
+                    or CommandStrings.XGD3Swap => (MediaType?)MediaType.DVD,
+                CommandStrings.BluRay => (MediaType?)MediaType.BluRay,
+
+                // Non-optical
+                CommandStrings.Floppy => (MediaType?)MediaType.FloppyDisk,
+                CommandStrings.Disk => (MediaType?)MediaType.HardDisk,
+                CommandStrings.Tape => (MediaType?)MediaType.DataCartridge,
+                _ => null,
+            };
+        }
+
+        /// <summary>
+        /// Get the default extension for a given disc type
+        /// </summary>
+        /// <param name="type">MediaType value to check</param>
+        /// <returns>Valid extension (with leading '.'), null on error</returns>
+        public static string? Extension(MediaType? type)
+        {
+            return type switch
+            {
+                MediaType.CDROM
+                    or MediaType.GDROM
+                    or MediaType.Cartridge
+                    or MediaType.HardDisk
+                    or MediaType.CompactFlash
+                    or MediaType.MMC
+                    or MediaType.SDCard
+                    or MediaType.FlashDrive => ".bin",
+                MediaType.DVD
+                    or MediaType.HDDVD
+                    or MediaType.BluRay
+                    or MediaType.NintendoWiiOpticalDisc => ".iso",
+                MediaType.LaserDisc
+                    or MediaType.NintendoGameCubeGameDisc => ".raw",
+                MediaType.NintendoWiiUOpticalDisc => ".wud",
+                MediaType.FloppyDisk => ".img",
+                MediaType.Cassette => ".wav",
+                _ => null,
+            };
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts/DiscImageCreator/FlagStrings.cs

@@ -0,0 +1,50 @@
+namespace MPF.ExecutionContexts.DiscImageCreator
+{
+    /// <summary>
+    /// Dumping flags for DiscImageCreator
+    /// </summary>
+    public static class FlagStrings
+    {
+        public const string AddOffset = "/a";
+        public const string AMSF = "/p";
+        public const string AtariJaguar = "/aj";
+        public const string BEOpcode = "/be";
+        public const string C2Opcode = "/c2";
+        public const string C2OpcodeNew = "/c2new";
+        public const string CopyrightManagementInformation = "/c";
+        public const string D8Opcode = "/d8";
+        public const string DatExpand = "/d";
+        public const string DisableBeep = "/q";
+        public const string DVDReread = "/rr";
+        public const string ExtractMicroSoftCabFile = "/mscf";
+        public const string Fix = "/fix";
+        public const string ForceDescrambleSector = "/fdesc";
+        public const string ForceUnitAccess = "/f";
+        public const string FullToc = "/fulltoc";
+        public const string MultiSectorRead = "/mr";
+        public const string NoFixSubP = "/np";
+        public const string NoFixSubQ = "/nq";
+        public const string NoFixSubQLibCrypt = "/nl";
+        public const string NoFixSubRtoW = "/nr";
+        public const string NoFixSubQSecuROM = "/ns";
+        public const string NoSkipSS = "/nss";
+        public const string PadSector = "/ps";
+        public const string Range = "/ra";
+        public const string Raw = "/raw";
+        public const string Resume = "/re";
+        public const string Reverse = "/r";
+        public const string ScanAntiMod = "/am";
+        public const string ScanFileProtect = "/sf";
+        public const string ScanSectorProtect = "/ss";
+        public const string SeventyFour = "/74";
+        public const string SkipSector = "/sk";
+        public const string SubchannelReadLevel = "/s";
+        public const string Tages = "/t";
+        public const string Toc = "/toc";
+        public const string TryReadingPregap = "/trp";
+        public const string UseAnchorVolumeDescriptorPointer = "/avdp";
+        public const string VideoNow = "/vn";
+        public const string VideoNowColor = "/vnc";
+        public const string VideoNowXP = "/vnx";
+    }
+}

MPF.ExecutionContexts/DiscImageCreator/SettingConstants.cs

@@ -0,0 +1,26 @@
+namespace MPF.ExecutionContexts.DiscImageCreator
+{
+    public static class SettingConstants
+    {
+        public const string DVDRereadCount = "DICDVDRereadCount";
+        public const int DVDRereadCountDefault = 10;
+
+        public const string MultiSectorRead = "DICMultiSectorRead";
+        public const bool MultiSectorReadDefault = false;
+
+        public const string MultiSectorReadValue = "DICMultiSectorReadValue";
+        public const int MultiSectorReadValueDefault = 0;
+
+        public const string ParanoidMode = "DICParanoidMode";
+        public const bool ParanoidModeDefault = false;
+
+        public const string QuietMode = "DICQuietMode";
+        public const bool QuietModeDefault = false;
+
+        public const string RereadCount = "DICRereadCount";
+        public const int RereadCountDefault = 20;
+
+        public const string UseCMIFlag = "DICUseCMIFlag";
+        public const bool UseCMIFlagDefault = false;
+    }
+}

MPF.ExecutionContexts/MPF.ExecutionContexts.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <!-- Assembly Properties -->
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <IncludeSymbols>true</IncludeSymbols>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <VersionPrefix>3.4.1</VersionPrefix>
+        <WarningsNotAsErrors>NU5104</WarningsNotAsErrors>
+
+        <!-- Package Properties -->
+        <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+        <Description>Common code for all MPF execution contexts</Description>
+        <Copyright>Copyright (c) Matt Nadareski 2019-2025</Copyright>
+        <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <None Include="README.md" Pack="true" PackagePath="" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <InternalsVisibleTo Include="MPF.ExecutionContexts.Test" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="SabreTools.RedumpLib" Version="1.7.4" />
+    </ItemGroup>
+
+</Project>

MPF.ExecutionContexts/README.md

@@ -0,0 +1,13 @@
+# MPF.ExecutionContexts
+
+This library represents the logic needed to invoke 3 different dumping programs:
+
+- [Aaru](github.com/aaru-dps/Aaru)
+- [DiscImageCreator](github.com/saramibreak/DiscImageCreator)
+- [Redumper](https://github.com/superg/redumper)
+
+These execution wrappers allow for generating valid parameters for each of the programs as well as provide some helpers that make it easier to determine what those parameters are.
+
+External options are defined in order to help create reasonable default parameter sets for different combinations of media type and system.
+
+Paths to the programs need to be provided if they are expected to be invoked as a part of another program. The expected versions of these programs can be found in either the changelog or the publish script in the parent project.

MPF.ExecutionContexts/Redumper/CommandStrings.cs

@@ -0,0 +1,32 @@
+namespace MPF.ExecutionContexts.Redumper
+{
+    /// <summary>
+    /// Top-level commands for Redumper
+    /// </summary>
+    public static class CommandStrings
+    {
+        public const string NONE = "";
+        public const string Disc = "disc";
+        public const string Rings = "rings";
+        public const string Dump = "dump";
+        public const string DumpExtra = "dump::extra";
+        public const string Refine = "refine";
+        public const string Verify = "verify";
+        public const string DVDKey = "dvdkey";
+        public const string Eject = "eject";
+        public const string DVDIsoKey = "dvdisokey";
+        public const string Protection = "protection";
+        public const string Split = "split";
+        public const string Hash = "hash";
+        public const string Info = "info";
+        public const string Skeleton = "skeleton";
+        public const string FlashMT1339 = "flash::mt1339";
+        public const string FlashSD616 = "flash::sd616";
+        public const string FlashPlextor = "flash::plextor";
+        public const string Subchannel = "subchannel";
+        public const string Debug = "debug";
+        public const string FixMSF = "fixmsf";
+        public const string DebugFlip = "debug::flip";
+        public const string DriveTest = "drive::test";
+    }
+}

MPF.ExecutionContexts/Redumper/Converters.cs

@@ -0,0 +1,32 @@
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.ExecutionContexts.Redumper
+{
+    public static class Converters
+    {
+        #region Cross-enumeration conversions
+
+        /// <summary>
+        /// Get the default extension for a given disc type
+        /// </summary>
+        /// <param name="type">MediaType value to check</param>
+        /// <returns>Valid extension (with leading '.'), null on error</returns>
+        public static string? Extension(MediaType? type)
+        {
+            return type switch
+            {
+                MediaType.CDROM
+                    or MediaType.GDROM => ".bin",
+                MediaType.DVD
+                    or MediaType.HDDVD
+                    or MediaType.BluRay
+                    or MediaType.NintendoWiiOpticalDisc => ".iso",
+                MediaType.NintendoGameCubeGameDisc => ".raw",
+                MediaType.NintendoWiiUOpticalDisc => ".wud",
+                _ => null,
+            };
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts/Redumper/Enumerations.cs

@@ -0,0 +1,42 @@
+namespace MPF.ExecutionContexts.Redumper
+{
+    /// <summary>
+    /// Drive type option
+    /// </summary>
+    public enum DriveType
+    {
+        NONE = 0,
+
+        GENERIC,
+        PLEXTOR,
+        LG_ASU8A,
+        LG_ASU8B,
+        LG_ASU8C,
+        LG_ASU3,
+        LG_ASU2,
+    }
+
+    /// <summary>
+    /// Drive read method option
+    /// </summary>
+    public enum ReadMethod
+    {
+        NONE = 0,
+
+        BE,
+        D8,
+    }
+
+    /// <summary>
+    /// Drive sector order option
+    /// </summary>
+    public enum SectorOrder
+    {
+        NONE = 0,
+
+        DATA_C2_SUB,
+        DATA_SUB_C2,
+        DATA_SUB,
+        DATA_C2,
+    }
+}

MPF.ExecutionContexts/Redumper/ExecutionContext.cs

@@ -0,0 +1,489 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using MPF.ExecutionContexts.Data;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.ExecutionContexts.Redumper
+{
+    /// <summary>
+    /// Represents a generic set of Redumper parameters
+    /// </summary>
+    public sealed class ExecutionContext : BaseExecutionContext
+    {
+        #region Generic Dumping Information
+
+        /// <inheritdoc/>
+        public override string? InputPath
+            => (_inputs[FlagStrings.Drive] as StringInput)?.Value?.Trim('"');
+
+        /// <inheritdoc/>
+        public override string? OutputPath => Path.Combine(
+                (_inputs[FlagStrings.ImagePath] as StringInput)?.Value?.Trim('"') ?? string.Empty,
+                (_inputs[FlagStrings.ImageName] as StringInput)?.Value?.Trim('"') ?? string.Empty)
+            + GetDefaultExtension(MediaType);
+
+        /// <inheritdoc/>
+        public override int? Speed
+        {
+            get
+            {
+                return (_inputs[FlagStrings.Speed] as Int32Input)?.Value;
+            }
+            set
+            {
+                if (value != null && value > 0)
+                {
+                    this[FlagStrings.Speed] = true;
+                    (_inputs[FlagStrings.Speed] as Int32Input)?.SetValue(value);
+                }
+                else
+                {
+                    this[FlagStrings.Speed] = false;
+                    (_inputs[FlagStrings.Speed] as Int32Input)?.SetValue(null);
+                }
+            }
+        }
+
+        #endregion
+
+        #region Flag Values
+
+        /// <summary>
+        /// Set of all command flags
+        /// </summary>
+        private readonly Dictionary<string, Input> _inputs = new()
+        {
+            // General
+            [FlagStrings.HelpLong] = new FlagInput(FlagStrings.HelpShort, FlagStrings.HelpLong),
+            [FlagStrings.Version] = new FlagInput(FlagStrings.Version),
+            [FlagStrings.Verbose] = new FlagInput(FlagStrings.Verbose),
+            [FlagStrings.ListRecommendedDrives] = new FlagInput(FlagStrings.ListRecommendedDrives),
+            [FlagStrings.ListAllDrives] = new FlagInput(FlagStrings.ListAllDrives),
+            [FlagStrings.AutoEject] = new FlagInput(FlagStrings.AutoEject),
+            [FlagStrings.Skeleton] = new FlagInput(FlagStrings.Skeleton),
+            [FlagStrings.Drive] = new StringInput(FlagStrings.Drive),
+            [FlagStrings.Speed] = new Int32Input(FlagStrings.Speed),
+            [FlagStrings.Retries] = new Int32Input(FlagStrings.Retries),
+            [FlagStrings.ImagePath] = new StringInput(FlagStrings.ImagePath) { Quotes = true },
+            [FlagStrings.ImageName] = new StringInput(FlagStrings.ImageName) { Quotes = true },
+            [FlagStrings.Overwrite] = new FlagInput(FlagStrings.Overwrite),
+            [FlagStrings.DiscType] = new StringInput(FlagStrings.DiscType),
+
+            // Drive Configuration
+            [FlagStrings.DriveType] = new StringInput(FlagStrings.DriveType),
+            [FlagStrings.DriveReadOffset] = new Int32Input(FlagStrings.DriveReadOffset),
+            [FlagStrings.DriveC2Shift] = new Int32Input(FlagStrings.DriveC2Shift),
+            [FlagStrings.DrivePregapStart] = new Int32Input(FlagStrings.DrivePregapStart),
+            [FlagStrings.DriveReadMethod] = new StringInput(FlagStrings.DriveReadMethod),
+            [FlagStrings.DriveSectorOrder] = new StringInput(FlagStrings.DriveSectorOrder),
+
+            // Drive Specific
+            [FlagStrings.PlextorSkipLeadin] = new FlagInput(FlagStrings.PlextorSkipLeadin),
+            [FlagStrings.PlextorLeadinRetries] = new Int32Input(FlagStrings.PlextorLeadinRetries),
+            [FlagStrings.PlextorLeadinForceStore] = new FlagInput(FlagStrings.PlextorLeadinForceStore),
+            [FlagStrings.KreonPartialSS] = new FlagInput(FlagStrings.KreonPartialSS),
+            [FlagStrings.AsusSkipLeadout] = new FlagInput(FlagStrings.AsusSkipLeadout),
+            [FlagStrings.AsusLeadoutRetries] = new Int32Input(FlagStrings.AsusLeadoutRetries),
+            [FlagStrings.DisableCDText] = new FlagInput(FlagStrings.DisableCDText),
+
+            // Offset
+            [FlagStrings.ForceOffset] = new Int32Input(FlagStrings.ForceOffset),
+            [FlagStrings.AudioSilenceThreshold] = new Int32Input(FlagStrings.AudioSilenceThreshold),
+            [FlagStrings.CorrectOffsetShift] = new FlagInput(FlagStrings.CorrectOffsetShift),
+            [FlagStrings.OffsetShiftRelocate] = new FlagInput(FlagStrings.OffsetShiftRelocate),
+
+            // Split
+            [FlagStrings.ForceSplit] = new FlagInput(FlagStrings.ForceSplit),
+            [FlagStrings.LeaveUnchanged] = new FlagInput(FlagStrings.LeaveUnchanged),
+            [FlagStrings.ForceQTOC] = new FlagInput(FlagStrings.ForceQTOC),
+            [FlagStrings.SkipFill] = new UInt8Input(FlagStrings.SkipFill),
+            [FlagStrings.ISO9660Trim] = new FlagInput(FlagStrings.ISO9660Trim),
+
+            // Drive Test
+            [FlagStrings.DriveTestSkipPlextorLeadin] = new FlagInput(FlagStrings.DriveTestSkipPlextorLeadin),
+            [FlagStrings.DriveTestSkipCacheRead] = new FlagInput(FlagStrings.DriveTestSkipCacheRead),
+
+            // Miscellaneous
+            [FlagStrings.Continue] = new StringInput(FlagStrings.Continue),
+            [FlagStrings.LBAStart] = new Int32Input(FlagStrings.LBAStart),
+            [FlagStrings.LBAEnd] = new Int32Input(FlagStrings.LBAEnd),
+            [FlagStrings.RefineSubchannel] = new FlagInput(FlagStrings.RefineSubchannel),
+            [FlagStrings.RefineSectorMode] = new FlagInput(FlagStrings.RefineSectorMode),
+            [FlagStrings.Skip] = new StringInput(FlagStrings.Skip),
+            [FlagStrings.DumpWriteOffset] = new Int32Input(FlagStrings.DumpWriteOffset),
+            [FlagStrings.DumpReadSize] = new Int32Input(FlagStrings.DumpReadSize),
+            [FlagStrings.OverreadLeadout] = new FlagInput(FlagStrings.OverreadLeadout),
+            [FlagStrings.ForceUnscrambled] = new FlagInput(FlagStrings.ForceUnscrambled),
+            [FlagStrings.ForceRefine] = new FlagInput(FlagStrings.ForceRefine),
+            //[FlagStrings.Firmware] = new StringInput(FlagStrings.Firmware) { Quotes = true },
+            [FlagStrings.SkipSubcodeDesync] = new FlagInput(FlagStrings.SkipSubcodeDesync),
+            [FlagStrings.Rings] = new FlagInput(FlagStrings.Rings),
+
+            // Undocumented
+            [FlagStrings.Debug] = new FlagInput(FlagStrings.Debug),
+            [FlagStrings.LegacySubs] = new FlagInput(FlagStrings.LegacySubs),
+        };
+
+        #endregion
+
+        /// <inheritdoc/>
+        public ExecutionContext(string? parameters) : base(parameters) { }
+
+        /// <inheritdoc/>
+        public ExecutionContext(RedumpSystem? system,
+            MediaType? type,
+            string? drivePath,
+            string filename,
+            int? driveSpeed,
+            Dictionary<string, string?> options)
+            : base(system, type, drivePath, filename, driveSpeed, options)
+        {
+        }
+
+        #region BaseExecutionContext Implementations
+
+        /// <inheritdoc/>
+        /// <remarks>Command support is irrelevant for redumper</remarks>
+        public override Dictionary<string, List<string>> GetCommandSupport()
+        {
+            return new Dictionary<string, List<string>>()
+            {
+                [CommandStrings.NONE] =
+                [
+                    // General
+                    FlagStrings.HelpLong,
+                    FlagStrings.HelpShort,
+                    FlagStrings.Version,
+                    FlagStrings.Verbose,
+                    FlagStrings.ListRecommendedDrives,
+                    FlagStrings.ListAllDrives,
+                    FlagStrings.AutoEject,
+                    FlagStrings.Skeleton,
+                    FlagStrings.Drive,
+                    FlagStrings.Speed,
+                    FlagStrings.Retries,
+                    FlagStrings.ImagePath,
+                    FlagStrings.ImageName,
+                    FlagStrings.Overwrite,
+                    FlagStrings.DiscType,
+
+                    // Drive Configuration
+                    FlagStrings.DriveType,
+                    FlagStrings.DriveReadOffset,
+                    FlagStrings.DriveC2Shift,
+                    FlagStrings.DrivePregapStart,
+                    FlagStrings.DriveReadMethod,
+                    FlagStrings.DriveSectorOrder,
+
+                    // Drive Specific
+                    FlagStrings.PlextorSkipLeadin,
+                    FlagStrings.PlextorLeadinRetries,
+                    FlagStrings.PlextorLeadinForceStore,
+                    FlagStrings.KreonPartialSS,
+                    FlagStrings.AsusSkipLeadout,
+                    FlagStrings.AsusLeadoutRetries,
+                    FlagStrings.DisableCDText,
+
+                    // Offset
+                    FlagStrings.ForceOffset,
+                    FlagStrings.AudioSilenceThreshold,
+                    FlagStrings.CorrectOffsetShift,
+                    FlagStrings.OffsetShiftRelocate,
+
+                    // Split
+                    FlagStrings.ForceSplit,
+                    FlagStrings.LeaveUnchanged,
+                    FlagStrings.ForceQTOC,
+                    FlagStrings.SkipFill,
+                    FlagStrings.ISO9660Trim,
+
+                    // Drive Test
+                    FlagStrings.DriveTestSkipPlextorLeadin,
+                    FlagStrings.DriveTestSkipCacheRead,
+
+                    // Miscellaneous
+                    FlagStrings.Continue,
+                    FlagStrings.LBAStart,
+                    FlagStrings.LBAEnd,
+                    FlagStrings.RefineSubchannel,
+                    FlagStrings.RefineSectorMode,
+                    FlagStrings.Skip,
+                    FlagStrings.DumpWriteOffset,
+                    FlagStrings.DumpReadSize,
+                    FlagStrings.OverreadLeadout,
+                    FlagStrings.ForceUnscrambled,
+                    FlagStrings.ForceRefine,
+                    //FlagStrings.Firmware,
+                    FlagStrings.SkipSubcodeDesync,
+                    FlagStrings.Rings,
+
+                    // Undocumented
+                    FlagStrings.Debug,
+                    FlagStrings.LegacySubs,
+                ],
+            };
+        }
+
+        /// <inheritdoc/>
+        /// <remarks>
+        /// Redumper is unique in that the base command can be multiple
+        /// modes all listed together. It is also unique in that "all
+        /// flags are supported for everything" and it filters out internally
+        /// </remarks>
+        public override string GenerateParameters()
+        {
+            var parameters = new StringBuilder();
+
+            // Command Mode
+            BaseCommand ??= CommandStrings.NONE;
+            if (BaseCommand != CommandStrings.NONE)
+                parameters.Append($"{BaseCommand} ");
+
+            // Loop though and append all existing
+            foreach (var kvp in _inputs)
+            {
+                // If the value doesn't exist
+                string formatted = kvp.Value.Format(useEquals: true);
+                if (formatted.Length == 0)
+                    continue;
+
+                // Append the parameter
+                parameters.Append($"{formatted} ");
+            }
+
+            return parameters.ToString().TrimEnd();
+        }
+
+        /// <inheritdoc/>
+        public override string? GetDefaultExtension(MediaType? mediaType) => Converters.Extension(mediaType);
+
+        /// <inheritdoc/>
+        public override MediaType? GetMediaType() => null;
+
+        /// <inheritdoc/>
+        public override bool IsDumpingCommand()
+        {
+            // `dump` command does not provide hashes so will error out after dump if run via MPF
+            return BaseCommand == CommandStrings.NONE
+                || BaseCommand == CommandStrings.Disc;
+        }
+
+        /// <inheritdoc/>
+        protected override void ResetValues()
+        {
+            BaseCommand = CommandStrings.NONE;
+
+            flags = [];
+
+            foreach (var kvp in _inputs)
+                kvp.Value.ClearValue();
+        }
+
+        /// <inheritdoc/>
+        protected override void SetDefaultParameters(string? drivePath,
+            string filename,
+            int? driveSpeed,
+            Dictionary<string, string?> options)
+        {
+            BaseCommand = CommandStrings.Disc;
+
+            if (drivePath != null)
+            {
+                this[FlagStrings.Drive] = true;
+                (_inputs[FlagStrings.Drive] as StringInput)?.SetValue(drivePath);
+            }
+
+            if (driveSpeed != null && driveSpeed > 0)
+            {
+                this[FlagStrings.Speed] = true;
+                (_inputs[FlagStrings.Speed] as Int32Input)?.SetValue(driveSpeed);
+            }
+            else
+            {
+                this[FlagStrings.Speed] = false;
+                (_inputs[FlagStrings.Speed] as Int32Input)?.SetValue(null);
+            }
+
+            // Set user-defined options
+            if (GetBooleanSetting(options, SettingConstants.EnableVerbose, SettingConstants.EnableVerboseDefault))
+            {
+                this[FlagStrings.Verbose] = true;
+                (_inputs[FlagStrings.Verbose] as FlagInput)?.SetValue(true);
+            }
+            if (GetBooleanSetting(options, SettingConstants.EnableSkeleton, SettingConstants.EnableSkeletonDefault))
+            {
+                // Enable skeleton for CD dumps only by default
+                switch (MediaType)
+                {
+                    case SabreTools.RedumpLib.Data.MediaType.CDROM:
+                        switch (RedumpSystem)
+                        {
+                            case SabreTools.RedumpLib.Data.RedumpSystem.SuperAudioCD:
+                                break;
+                            default:
+                                this[FlagStrings.Skeleton] = true;
+                                (_inputs[FlagStrings.Skeleton] as FlagInput)?.SetValue(true);
+                                break;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+
+            string? readMethod = GetStringSetting(options, SettingConstants.ReadMethod, SettingConstants.ReadMethodDefault);
+            if (!string.IsNullOrEmpty(readMethod) && readMethod != ReadMethod.NONE.ToString())
+            {
+                this[FlagStrings.DriveReadMethod] = true;
+                (_inputs[FlagStrings.DriveReadMethod] as StringInput)?.SetValue(readMethod!);
+            }
+
+            string? sectorOrder = GetStringSetting(options, SettingConstants.SectorOrder, SettingConstants.SectorOrderDefault);
+            if (!string.IsNullOrEmpty(sectorOrder) && sectorOrder != SectorOrder.NONE.ToString())
+            {
+                this[FlagStrings.DriveSectorOrder] = true;
+                (_inputs[FlagStrings.DriveSectorOrder] as StringInput)?.SetValue(sectorOrder!);
+            }
+
+            string? driveType = GetStringSetting(options, SettingConstants.DriveType, SettingConstants.DriveTypeDefault);
+            if (!string.IsNullOrEmpty(driveType) && driveType != DriveType.NONE.ToString())
+            {
+                this[FlagStrings.DriveType] = true;
+                (_inputs[FlagStrings.DriveType] as StringInput)?.SetValue(driveType!);
+            }
+
+            // Set the output paths
+            if (!string.IsNullOrEmpty(filename))
+            {
+                var imagePath = Path.GetDirectoryName(filename);
+                if (!string.IsNullOrEmpty(imagePath))
+                {
+                    this[FlagStrings.ImagePath] = true;
+                    (_inputs[FlagStrings.ImagePath] as StringInput)?.SetValue(imagePath!);
+                }
+
+                string imageName = Path.GetFileNameWithoutExtension(filename);
+                if (!string.IsNullOrEmpty(imageName))
+                {
+                    this[FlagStrings.ImageName] = true;
+                    (_inputs[FlagStrings.ImageName] as StringInput)?.SetValue(imageName!);
+                }
+            }
+
+            int retries = GetInt32Setting(options, SettingConstants.RereadCount, SettingConstants.RereadCountDefault);
+            if (retries > 0)
+            {
+                this[FlagStrings.Retries] = true;
+                (_inputs[FlagStrings.Retries] as Int32Input)?.SetValue(retries);
+            }
+
+            int leadinRetries = GetInt32Setting(options, SettingConstants.LeadinRetryCount, SettingConstants.LeadinRetryCountDefault);
+            if (leadinRetries != SettingConstants.LeadinRetryCountDefault)
+            {
+                this[FlagStrings.PlextorLeadinRetries] = true;
+                (_inputs[FlagStrings.PlextorLeadinRetries] as Int32Input)?.SetValue(leadinRetries);
+            }
+
+            if (GetBooleanSetting(options, SettingConstants.RefineSectorMode, SettingConstants.RefineSectorModeDefault))
+            {
+                this[FlagStrings.RefineSectorMode] = true;
+                (_inputs[FlagStrings.RefineSectorMode] as FlagInput)?.SetValue(true);
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override bool ValidateAndSetParameters(string? parameters)
+        {
+            // The string has to be valid by itself first
+            if (string.IsNullOrEmpty(parameters))
+                return false;
+
+            // Now split the string into parts for easier validation
+            string[] parts = SplitParameterString(parameters!);
+
+            // Setup the modes
+            BaseCommand = null;
+
+            // All modes should be cached separately
+            int index = 0;
+            for (; index < parts.Length; index++)
+            {
+                // Flag to see if we have a flag
+                bool isFlag = false;
+
+                string part = parts[index];
+                switch (part)
+                {
+                    case CommandStrings.Disc:
+                    case CommandStrings.Rings:
+                    case CommandStrings.Dump:
+                    case CommandStrings.DumpExtra:
+                    case CommandStrings.Refine:
+                    case CommandStrings.Verify:
+                    case CommandStrings.DVDKey:
+                    case CommandStrings.Eject:
+                    case CommandStrings.DVDIsoKey:
+                    case CommandStrings.Protection:
+                    case CommandStrings.Split:
+                    case CommandStrings.Hash:
+                    case CommandStrings.Info:
+                    case CommandStrings.Skeleton:
+                    case CommandStrings.FlashMT1339:
+                    case CommandStrings.FlashSD616:
+                    case CommandStrings.FlashPlextor:
+                    case CommandStrings.Subchannel:
+                    case CommandStrings.Debug:
+                    case CommandStrings.FixMSF:
+                    case CommandStrings.DebugFlip:
+                    case CommandStrings.DriveTest:
+                        // Only allow one mode per command
+                        if (BaseCommand != null)
+                            continue;
+
+                        BaseCommand = part;
+                        break;
+
+                    // Default is either a flag or an invalid mode
+                    default:
+                        if (part.StartsWith("-"))
+                        {
+                            isFlag = true;
+                            break;
+                        }
+                        else
+                        {
+                            return false;
+                        }
+                }
+
+                // If we had a flag, break out
+                if (isFlag)
+                    break;
+            }
+
+            // Loop through all auxiliary flags, if necessary
+            for (int i = index; i < parts.Length; i++)
+            {
+                // Match all possible flags
+                foreach (var kvp in _inputs)
+                {
+                    // If the value was not a match
+                    if (!kvp.Value.Process(parts, ref i))
+                        continue;
+
+                    // Set the flag
+                    this[kvp.Key] = true;
+                }
+            }
+
+            // If the image name was not set, set it with a default value
+            if (string.IsNullOrEmpty((_inputs[FlagStrings.ImageName] as StringInput)?.Value))
+                (_inputs[FlagStrings.ImageName] as StringInput)?.SetValue("track");
+
+            return true;
+        }
+
+        #endregion
+    }
+}

MPF.ExecutionContexts/Redumper/FlagStrings.cs

@@ -0,0 +1,103 @@
+namespace MPF.ExecutionContexts.Redumper
+{
+    /// <summary>
+    /// Dumping flags for Redumper
+    /// </summary>
+    public static class FlagStrings
+    {
+        #region General
+
+        public const string HelpLong = "--help";
+        public const string HelpShort = "-h";
+        public const string Version = "--version";
+        public const string Verbose = "--verbose";
+        public const string ListRecommendedDrives = "--list-recommended-drives";
+        public const string ListAllDrives = "--list-all-drives";
+        public const string AutoEject = "--auto-eject";
+        public const string Skeleton = "--skeleton";
+        public const string Drive = "--drive";
+        public const string Speed = "--speed";
+        public const string Retries = "--retries";
+        public const string ImagePath = "--image-path";
+        public const string ImageName = "--image-name";
+        public const string Overwrite = "--overwrite";
+        public const string DiscType = "--disc-type";
+
+        #endregion
+
+        #region Drive Configuration
+
+        public const string DriveType = "--drive-type";
+        public const string DriveReadOffset = "--drive-read-offset";
+        public const string DriveC2Shift = "--drive-c2-shift";
+        public const string DrivePregapStart = "--drive-pregap-start";
+        public const string DriveReadMethod = "--drive-read-method";
+        public const string DriveSectorOrder = "--drive-sector-order";
+
+        #endregion
+
+        #region Drive Specific
+
+        public const string PlextorSkipLeadin = "--plextor-skip-leadin";
+        public const string PlextorLeadinRetries = "--plextor-leadin-retries";
+        public const string PlextorLeadinForceStore = "--plextor-leadin-force-store";
+        public const string KreonPartialSS = "--kreon-partial-ss";
+        public const string AsusSkipLeadout = "--asus-skip-leadout";
+        public const string AsusLeadoutRetries = "--asus-leadout-retries";
+        public const string DisableCDText = "--disable-cdtext";
+
+        #endregion
+
+        #region Offset
+
+        public const string ForceOffset = "--force-offset";
+        public const string AudioSilenceThreshold = "--audio-silence-threshold";
+        public const string CorrectOffsetShift = "--correct-offset-shift";
+        public const string OffsetShiftRelocate = "--offset-shift-relocate";
+
+        #endregion
+
+        #region Split
+
+        public const string ForceSplit = "--force-split";
+        public const string LeaveUnchanged = "--leave-unchanged";
+        public const string ForceQTOC = "--force-qtoc";
+        public const string SkipFill = "--skip-fill";
+        public const string ISO9660Trim = "--iso9660-trim";
+
+        #endregion
+
+        #region Drive Test
+
+        public const string DriveTestSkipPlextorLeadin = "--drive-test-skip-plextor-leadin";
+        public const string DriveTestSkipCacheRead = "--drive-test-skip-cache-read";
+
+        #endregion
+
+        #region Miscellaneous
+
+        public const string Continue = "--continue";
+        public const string LBAStart = "--lba-start";
+        public const string LBAEnd = "--lba-end";
+        public const string RefineSubchannel = "--refine-subchannel";
+        public const string RefineSectorMode = "--refine-sector-mode";
+        public const string Skip = "--skip";
+        public const string DumpWriteOffset = "--dump-write-offset";
+        public const string DumpReadSize = "--dump-read-size";
+        public const string OverreadLeadout = "--overread-leadout";
+        public const string ForceUnscrambled = "--force-unscrambled";
+        public const string ForceRefine = "--force-refine";
+        public const string Firmware = "--firmware";
+        public const string SkipSubcodeDesync = "--skip-subcode-desync";
+        public const string Rings = "--rings";
+
+        #endregion
+
+        #region Undocumented
+
+        public const string Debug = "--debug";
+        public const string LegacySubs = "--legacy-subs";
+
+        #endregion
+    }
+}

MPF.ExecutionContexts/Redumper/SettingConstants.cs

@@ -0,0 +1,29 @@
+namespace MPF.ExecutionContexts.Redumper
+{
+    public static class SettingConstants
+    {
+        public const string DriveType = "RedumperDriveType";
+        public static readonly string DriveTypeDefault = Redumper.DriveType.NONE.ToString();
+
+        public const string EnableSkeleton = "RedumperEnableSkeleton";
+        public const bool EnableSkeletonDefault = true;
+
+        public const string EnableVerbose = "RedumperEnableVerbose";
+        public const bool EnableVerboseDefault = false;
+
+        public const string LeadinRetryCount = "RedumperLeadinRetryCount";
+        public const int LeadinRetryCountDefault = 4;
+
+        public const string ReadMethod = "RedumperReadMethod";
+        public static readonly string ReadMethodDefault = Redumper.ReadMethod.NONE.ToString();
+
+        public const string RefineSectorMode = "RedumperRefineSectorMode";
+        public const bool RefineSectorModeDefault = false;
+
+        public const string RereadCount = "RedumperRereadCount";
+        public const int RereadCountDefault = 20;
+
+        public const string SectorOrder = "RedumperSectorOrder";
+        public static readonly string SectorOrderDefault = Redumper.SectorOrder.NONE.ToString();
+    }
+}

MPF.Frontend.Test/DriveTests.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Xunit;
+
+namespace MPF.Frontend.Test
+{
+    public class DriveTests
+    {
+        #region ToInternalDriveType
+
+        /// <summary>
+        /// DiscType values that map to InternalDriveType
+        /// </summary>
+        private static readonly DriveType[] _mappableDriveTypes =
+        [
+            DriveType.CDRom,
+            DriveType.Fixed,
+            DriveType.Removable,
+        ];
+
+        /// <summary>
+        /// Check that every supported DriveType maps to an InternalDriveType
+        /// </summary>
+        /// <param name="driveType">DriveType value to check</param>
+        /// <param name="expectNull">True to expect a null mapping, false otherwise</param>
+        [Theory]
+        [MemberData(nameof(GenerateDriveTypeMappingTestData))]
+        public void ToInternalDriveTypeTest(DriveType driveType, bool expectNull)
+        {
+            var actual = Drive.ToInternalDriveType(driveType);
+
+            if (expectNull)
+                Assert.Null(actual);
+            else
+                Assert.NotNull(actual);
+        }
+
+        /// <summary>
+        /// Generate a test set of DriveType values
+        /// </summary>
+        /// <returns>MemberData-compatible list of DriveType values</returns>
+        public static List<object?[]> GenerateDriveTypeMappingTestData()
+        {
+            var testData = new List<object?[]>() { new object?[] { null, true } };
+            foreach (DriveType driveType in Enum.GetValues(typeof(DriveType)))
+            {
+                if (Array.IndexOf(_mappableDriveTypes, driveType) > -1)
+                    testData.Add([driveType, false]);
+                else
+                    testData.Add([driveType, true]);
+            }
+
+            return testData;
+        }
+
+        #endregion
+    }
+}

MPF.Frontend.Test/DumpEnvironmentTests.cs

@@ -0,0 +1,37 @@
+using SabreTools.RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Frontend.Test
+{
+    public class DumpEnvironmentTests
+    {
+        [Theory]
+        [InlineData(null, 'D', false, MediaType.NONE, false)]
+        [InlineData("", 'D', false, MediaType.NONE, false)]
+        [InlineData("cd F test.bin 8 /c2 20", 'F', false, MediaType.CDROM, true)]
+        [InlineData("cd F test.bin 8 /c2new 20", 'F', false, MediaType.CDROM, true)]
+        [InlineData("fd A test.img", 'A', true, MediaType.FloppyDisk, true)]
+        [InlineData("dvd X test.iso 8 /raw", 'X', false, MediaType.FloppyDisk, false)]
+        [InlineData("stop D", 'D', false, MediaType.DVD, true)]
+        public void ParametersValidTest(string? parameters, char letter, bool isFloppy, MediaType? mediaType, bool expected)
+        {
+            var options = new Options() { InternalProgram = InternalProgram.DiscImageCreator };
+
+            // TODO: This relies on creating real objects for the drive. Can we mock this out instead?
+            var drive = isFloppy
+                ? Drive.Create(InternalDriveType.Floppy, letter.ToString())
+                : Drive.Create(InternalDriveType.Optical, letter.ToString());
+
+            var env = new DumpEnvironment(options,
+                string.Empty,
+                drive,
+                RedumpSystem.IBMPCcompatible,
+                null);
+            env.SetExecutionContext(mediaType, parameters);
+            env.SetProcessor();
+
+            bool actual = env.ParametersValid(mediaType);
+            Assert.Equal(expected, actual);
+        }
+    }
+}

MPF.Frontend.Test/EnumExtensionsTests.cs

@@ -0,0 +1,180 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using SabreTools.RedumpLib.Data;
+using Xunit;
+using RedumperDriveType = MPF.ExecutionContexts.Redumper.DriveType;
+using RedumperReadMethod = MPF.ExecutionContexts.Redumper.ReadMethod;
+using RedumperSectorOrder = MPF.ExecutionContexts.Redumper.SectorOrder;
+
+namespace MPF.Frontend.Test
+{
+    public class EnumExtensionsTests
+    {
+        #region Long Name
+
+        [Theory]
+        [InlineData(null, "Unknown")]
+        [InlineData(InternalProgram.NONE, "Unknown")]
+        [InlineData(InternalProgram.Aaru, "Aaru")]
+        [InlineData(InternalProgram.DiscImageCreator, "DiscImageCreator")]
+        [InlineData(InternalProgram.Redumper, "Redumper")]
+        [InlineData(InternalProgram.CleanRip, "CleanRip")]
+        [InlineData(InternalProgram.PS3CFW, "PS3 CFW")]
+        [InlineData(InternalProgram.UmdImageCreator, "UmdImageCreator")]
+        [InlineData(InternalProgram.XboxBackupCreator, "XboxBackupCreator")]
+        public void LongName_InternalProgram(InternalProgram? prog, string? expected)
+        {
+            string? actual = prog.LongName();
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [InlineData(null, "Unknown")]
+        [InlineData(RedumperReadMethod.NONE, "Default")]
+        [InlineData(RedumperReadMethod.D8, "D8")]
+        [InlineData(RedumperReadMethod.BE, "BE")]
+        public void LongName_RedumperReadMethod(RedumperReadMethod? method, string? expected)
+        {
+            string? actual = method.LongName();
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [InlineData(null, "Unknown")]
+        [InlineData(RedumperSectorOrder.NONE, "Default")]
+        [InlineData(RedumperSectorOrder.DATA_C2_SUB, "DATA_C2_SUB")]
+        [InlineData(RedumperSectorOrder.DATA_SUB_C2, "DATA_SUB_C2")]
+        [InlineData(RedumperSectorOrder.DATA_SUB, "DATA_SUB")]
+        [InlineData(RedumperSectorOrder.DATA_C2, "DATA_C2")]
+        public void LongName_RedumperSectorOrder(RedumperSectorOrder? order, string? expected)
+        {
+            string? actual = order.LongName();
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [InlineData(null, "Unknown")]
+        [InlineData(RedumperDriveType.NONE, "Default")]
+        [InlineData(RedumperDriveType.GENERIC, "GENERIC")]
+        [InlineData(RedumperDriveType.PLEXTOR, "PLEXTOR")]
+        [InlineData(RedumperDriveType.LG_ASU8A, "LG_ASU8A")]
+        [InlineData(RedumperDriveType.LG_ASU8B, "LG_ASU8B")]
+        [InlineData(RedumperDriveType.LG_ASU8C, "LG_ASU8C")]
+        [InlineData(RedumperDriveType.LG_ASU3, "LG_ASU3")]
+        [InlineData(RedumperDriveType.LG_ASU2, "LG_ASU2")]
+        public void LongName_RedumperDriveType(RedumperDriveType? type, string? expected)
+        {
+            string? actual = type.LongName();
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region Short Name
+
+        [Theory]
+        [InlineData(null, "Unknown")]
+        [InlineData(InternalProgram.NONE, "Unknown")]
+        [InlineData(InternalProgram.Aaru, "aaru")]
+        [InlineData(InternalProgram.DiscImageCreator, "dic")]
+        [InlineData(InternalProgram.Redumper, "redumper")]
+        [InlineData(InternalProgram.CleanRip, "cleanrip")]
+        [InlineData(InternalProgram.PS3CFW, "ps3cfw")]
+        [InlineData(InternalProgram.UmdImageCreator, "uic")]
+        [InlineData(InternalProgram.XboxBackupCreator, "xbc")]
+        public void ShortName_InternalProgram(InternalProgram? prog, string? expected)
+        {
+            string? actual = prog.ShortName();
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region From String
+
+        [Theory]
+        [InlineData(null, InternalProgram.NONE)]
+        [InlineData("", InternalProgram.NONE)]
+        [InlineData("aaru", InternalProgram.Aaru)]
+        [InlineData("dic", InternalProgram.DiscImageCreator)]
+        [InlineData("redumper", InternalProgram.Redumper)]
+        [InlineData("cleanrip", InternalProgram.CleanRip)]
+        [InlineData("ps3cfw", InternalProgram.PS3CFW)]
+        [InlineData("uic", InternalProgram.UmdImageCreator)]
+        [InlineData("xbc", InternalProgram.XboxBackupCreator)]
+        public void ToInternalProgramTest(string? internalProgram, InternalProgram expected)
+        {
+            InternalProgram actual = internalProgram.ToInternalProgram();
+            Assert.Equal(expected, actual);
+        }
+
+        // TODO: Write remaining from-string tests
+
+        #endregion
+
+        #region Functionality Support
+
+        private static readonly RedumpSystem?[] _antiModchipSystems =
+        [
+            RedumpSystem.SonyPlayStation,
+        ];
+
+        private static readonly RedumpSystem?[] _copyProtectionSystems =
+        [
+            RedumpSystem.AppleMacintosh,
+            RedumpSystem.EnhancedCD ,
+            RedumpSystem.IBMPCcompatible,
+            RedumpSystem.PalmOS,
+            RedumpSystem.PocketPC,
+            RedumpSystem.RainbowDisc,
+            RedumpSystem.SonyElectronicBook,
+        ];
+
+        [Theory]
+        [MemberData(nameof(GenerateSupportsAntiModchipScansData))]
+        public void SupportsAntiModchipScansTest(RedumpSystem? redumpSystem, bool expected)
+        {
+            bool actual = redumpSystem.SupportsAntiModchipScans();
+            Assert.Equal(expected, actual);
+        }
+
+        [Theory]
+        [MemberData(nameof(GenerateSupportsCopyProtectionScansData))]
+        public void SupportsCopyProtectionScansTest(RedumpSystem? redumpSystem, bool expected)
+        {
+            bool actual = redumpSystem.SupportsCopyProtectionScans();
+            Assert.Equal(expected, actual);
+        }
+
+        public static List<object?[]> GenerateSupportsAntiModchipScansData()
+        {
+            var testData = new List<object?[]>() { new object?[] { null, false } };
+            foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                if (_antiModchipSystems.Contains(redumpSystem))
+                    testData.Add([redumpSystem, true]);
+                else
+                    testData.Add([redumpSystem, false]);
+            }
+
+            return testData;
+        }
+
+        public static List<object?[]> GenerateSupportsCopyProtectionScansData()
+        {
+            var testData = new List<object?[]>() { new object?[] { null, false } };
+            foreach (RedumpSystem redumpSystem in Enum.GetValues(typeof(RedumpSystem)))
+            {
+                if (_copyProtectionSystems.Contains(redumpSystem))
+                    testData.Add([redumpSystem, true]);
+                else
+                    testData.Add([redumpSystem, false]);
+            }
+
+            return testData;
+        }
+
+        #endregion
+    }
+}

MPF.Frontend.Test/InterfaceConstantsTests.cs

@@ -0,0 +1,24 @@
+using SabreTools.RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Frontend.Test
+{
+    public class InterfaceConstantsTests
+    {
+        [Theory]
+        [InlineData(MediaType.CDROM, 72)]
+        [InlineData(MediaType.DVD, 24)]
+        [InlineData(MediaType.NintendoGameCubeGameDisc, 24)]
+        [InlineData(MediaType.NintendoWiiOpticalDisc, 24)]
+        [InlineData(MediaType.HDDVD, 24)]
+        [InlineData(MediaType.BluRay, 16)]
+        [InlineData(MediaType.NintendoWiiUOpticalDisc, 16)]
+        [InlineData(MediaType.LaserDisc, 72)]
+        [InlineData(null, 72)]
+        public void GetAllowedDriveSpeedForMediaTypeTest(MediaType? mediaType, int maxExpected)
+        {
+            var actual = InterfaceConstants.GetSpeedsForMediaType(mediaType);
+            Assert.Equal(maxExpected, actual[actual.Count - 1]);
+        }
+    }
+}

MPF.Frontend.Test/MPF.Frontend.Test.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <LangVersion>latest</LangVersion>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\MPF.Frontend\MPF.Frontend.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="Microsoft.CodeCoverage" Version="17.14.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
+        <PackageReference Include="SabreTools.RedumpLib" Version="1.7.4" />
+        <PackageReference Include="xunit" Version="2.9.3" />
+        <PackageReference Include="xunit.abstractions" Version="2.0.3" />
+        <PackageReference Include="xunit.analyzers" Version="1.24.0" />
+        <PackageReference Include="xunit.assert" Version="2.9.3" />
+        <PackageReference Include="xunit.core" Version="2.9.3" />
+        <PackageReference Include="xunit.extensibility.core" Version="2.9.3" />
+        <PackageReference Include="xunit.extensibility.execution" Version="2.9.3" />
+        <PackageReference Include="xunit.runner.console" Version="2.9.3">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
+
+</Project>

MPF.Frontend.Test/OptionsTests.cs

@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using Xunit;
+
+namespace MPF.Frontend.Test
+{
+    public class OptionsTests
+    {
+        [Theory]
+        [InlineData("key2", null, "key", false, false)]
+        [InlineData("key", null, "key", false, false)]
+        [InlineData("key", "", "key", false, false)]
+        [InlineData("key", "INVALID", "key", false, false)]
+        [InlineData("key", "true", "key", false, true)]
+        public void GetBooleanSettingTest(string key, string? value, string expectedKey, bool defaultValue, bool expectedValue)
+        {
+            Dictionary<string, string?> settings = new() { [key] = value };
+            bool actual = Options.GetBooleanSetting(settings, expectedKey, defaultValue);
+            Assert.Equal(expectedValue, actual);
+        }
+
+        [Theory]
+        [InlineData("key2", null, "key", -1, -1)]
+        [InlineData("key", null, "key", -1, -1)]
+        [InlineData("key", "", "key", -1, -1)]
+        [InlineData("key", "INVALID", "key", -1, -1)]
+        [InlineData("key", "12345", "key", -1, 12345)]
+        public void GetInt32SettingTest(string key, string? value, string expectedKey, int defaultValue, int expectedValue)
+        {
+            Dictionary<string, string?> settings = new() { [key] = value };
+            int actual = Options.GetInt32Setting(settings, expectedKey, defaultValue);
+            Assert.Equal(expectedValue, actual);
+        }
+
+        [Theory]
+        [InlineData("key2", null, "key", null, null)]
+        [InlineData("key", null, "key", null, null)]
+        [InlineData("key", "", "key", null, "")]
+        [InlineData("key", "INVALID", "key", null, "INVALID")]
+        [InlineData("key", "String", "key", null, "String")]
+        public void GetStringSettingTest(string key, string? value, string expectedKey, string? defaultValue, string? expectedValue)
+        {
+            Dictionary<string, string?> settings = new() { [key] = value };
+            string? actual = Options.GetStringSetting(settings, expectedKey, defaultValue);
+            Assert.Equal(expectedValue, actual);
+        }
+    }
+}

MPF.Frontend.Test/ResultEventArgsTests.cs

@@ -0,0 +1,41 @@
+using Xunit;
+
+namespace MPF.Frontend.Test
+{
+    public class ResultEventArgsTests
+    {
+        [Fact]
+        public void EmptySuccessTest()
+        {
+            var actual = ResultEventArgs.Success();
+            Assert.True(actual);
+            Assert.Empty(actual.Message);
+        }
+
+        [Fact]
+        public void CustomMessageSuccessTest()
+        {
+            string message = "Success!";
+            var actual = ResultEventArgs.Success(message);
+            Assert.True(actual);
+            Assert.Equal(message, actual.Message);
+        }
+
+        [Fact]
+        public void EmptyFailureTest()
+        {
+            var actual = ResultEventArgs.Failure();
+            Assert.False(actual);
+            Assert.Empty(actual.Message);
+        }
+
+        [Fact]
+        public void CustomMessageFailureTest()
+        {
+            string message = "Failure!";
+            var actual = ResultEventArgs.Failure(message);
+            Assert.False(actual);
+            Assert.Equal(message, actual.Message);
+        }
+    }
+}

MPF.Frontend.Test/Tools/FrontendToolTests.cs

@@ -0,0 +1,100 @@
+using System.IO;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Frontend.Test.Tools
+{
+    public class FrontendToolTests
+    {
+        #region GetDefaultSpeedForMediaType
+
+        [Theory]
+        [InlineData(null, 72)]
+        [InlineData(MediaType.CDROM, 72)]
+        [InlineData(MediaType.GDROM, 72)]
+        [InlineData(MediaType.DVD, 24)]
+        [InlineData(MediaType.NintendoGameCubeGameDisc, 24)]
+        [InlineData(MediaType.NintendoWiiOpticalDisc, 24)]
+        [InlineData(MediaType.HDDVD, 24)]
+        [InlineData(MediaType.BluRay, 16)]
+        [InlineData(MediaType.NintendoWiiUOpticalDisc, 16)]
+        public void GetDefaultSpeedForMediaTypeTest(MediaType? mediaType, int expected)
+        {
+            Options options = new Options
+            {
+                PreferredDumpSpeedCD = 72,
+                PreferredDumpSpeedDVD = 24,
+                PreferredDumpSpeedHDDVD = 24,
+                PreferredDumpSpeedBD = 16,
+            };
+
+            int actual = FrontendTool.GetDefaultSpeedForMediaType(mediaType, options);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region GetRedumpSystemFromVolumeLabel
+
+        [Theory]
+        [InlineData(null, null)]
+        [InlineData("", null)]
+        [InlineData("Audio CD", RedumpSystem.AudioCD)]
+        [InlineData("SEP13011042", RedumpSystem.MicrosoftXbox)]
+        [InlineData("SEP13011042072", RedumpSystem.MicrosoftXbox)]
+        [InlineData("XBOX360", RedumpSystem.MicrosoftXbox360)]
+        [InlineData("XGD2DVD_NTSC", RedumpSystem.MicrosoftXbox360)]
+        [InlineData("Sega_CD", RedumpSystem.SegaMegaCDSegaCD)]
+        [InlineData("PS3VOLUME", RedumpSystem.SonyPlayStation3)]
+        [InlineData("PS4VOLUME", RedumpSystem.SonyPlayStation4)]
+        [InlineData("PS5VOLUME", RedumpSystem.SonyPlayStation5)]
+        public void GetRedumpSystemFromVolumeLabelTest(string? volumeLabel, RedumpSystem? expected)
+        {
+            RedumpSystem? actual = FrontendTool.GetRedumpSystemFromVolumeLabel(volumeLabel);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+
+        #region NormalizeDiscTitle
+
+        // TODO: Write NormalizeDiscTitle(string?, Language?[]?) test
+        // TODO: Write NormalizeDiscTitle(string?, Language?) test
+
+        #endregion
+
+        #region NormalizeOutputPaths
+
+        [Theory]
+        [InlineData(null, false, "")]
+        [InlineData(null, true, "")]
+        [InlineData("", false, "")]
+        [InlineData("", true, "")]
+        [InlineData("filename.bin", false, "filename.bin")]
+        [InlineData("filename.bin", true, "filename.bin")]
+        [InlineData("\"filename.bin\"", false, "filename.bin")]
+        [InlineData("\"filename.bin\"", true, "filename.bin")]
+        [InlineData("<filename.bin>", false, "filename.bin")]
+        [InlineData("<filename.bin>", true, "filename.bin")]
+        [InlineData("1.2.3.4..bin", false, "1.2.3.4..bin")]
+        [InlineData("1.2.3.4..bin", true, "1.2.3.4..bin")]
+        [InlineData("dir/filename.bin", false, "dir/filename.bin")]
+        [InlineData("dir/filename.bin", true, "dir/filename.bin")]
+        [InlineData(" dir / filename.bin", false, "dir/filename.bin")]
+        [InlineData(" dir / filename.bin", true, "dir/filename.bin")]
+        [InlineData("\0dir/\0filename.bin", false, "_dir/_filename.bin")]
+        [InlineData("\0dir/\0filename.bin", true, "_dir/_filename.bin")]
+        public void NormalizeOutputPathsTest(string? path, bool getFullPath, string expected)
+        {
+            // Modify expected to account for test data if necessary
+            if (getFullPath && !string.IsNullOrEmpty(expected))
+                expected = Path.GetFullPath(expected);
+
+            string actual = FrontendTool.NormalizeOutputPaths(path, getFullPath);
+            Assert.Equal(expected, actual);
+        }
+
+        #endregion
+    }
+}

MPF.Frontend.Test/Tools/InfoToolTests.cs

@@ -0,0 +1,142 @@
+using System.Collections.Generic;
+using System.IO;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+using Xunit;
+
+namespace MPF.Frontend.Test.Tools
+{
+    public class InfoToolTests
+    {
+        [Fact]
+        public void ProcessSpecialFieldsCompleteTest()
+        {
+            // Create a new SubmissionInfo object
+            var info = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    Comments = "This is a comments line\n[T:ISBN] ISBN Value",
+                    CommentsSpecialFields = new Dictionary<SiteCode, string>()
+                    {
+                        [SiteCode.VolumeLabel] = "VOLUME_LABEL",
+                    },
+
+                    Contents = "This is a contents line\n[T:GF] Game Footage",
+                    ContentsSpecialFields = new Dictionary<SiteCode, string>()
+                    {
+                        [SiteCode.Patches] = "1.04 patch",
+                    },
+                }
+            };
+
+            // Process the special fields
+            Formatter.ProcessSpecialFields(info);
+
+            // Validate the basics
+            Assert.NotNull(info.CommonDiscInfo.Comments);
+            Assert.Null(info.CommonDiscInfo.CommentsSpecialFields);
+            Assert.NotNull(info.CommonDiscInfo.Contents);
+            Assert.Null(info.CommonDiscInfo.ContentsSpecialFields);
+
+            // Split the values
+            string[] splitComments = info.CommonDiscInfo.Comments.Split('\n');
+            string[] splitContents = info.CommonDiscInfo.Contents.Split('\n');
+
+            // Validate the lines
+            Assert.Equal(3, splitComments.Length);
+            Assert.Equal(4, splitContents.Length);
+        }
+
+        [Fact]
+        public void ProcessSpecialFieldsNullObjectTest()
+        {
+            // Create a new SubmissionInfo object
+            var info = new SubmissionInfo()
+            {
+                CommonDiscInfo = null,
+            };
+
+            // Process the special fields
+            Formatter.ProcessSpecialFields(info);
+
+            // Validate
+            Assert.Null(info.CommonDiscInfo);
+        }
+
+        [Fact]
+        public void ProcessSpecialFieldsNullCommentsContentsTest()
+        {
+            // Create a new SubmissionInfo object
+            var info = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    Comments = null,
+                    CommentsSpecialFields = new Dictionary<SiteCode, string>()
+                    {
+                        [SiteCode.VolumeLabel] = "VOLUME_LABEL",
+                    },
+
+                    Contents = null,
+                    ContentsSpecialFields = new Dictionary<SiteCode, string>()
+                    {
+                        [SiteCode.Patches] = "1.04 patch",
+                    },
+                }
+            };
+
+            // Process the special fields
+            Formatter.ProcessSpecialFields(info);
+
+            // Validate the basics
+            Assert.NotNull(info.CommonDiscInfo.Comments);
+            Assert.Null(info.CommonDiscInfo.CommentsSpecialFields);
+            Assert.NotNull(info.CommonDiscInfo.Contents);
+            Assert.Null(info.CommonDiscInfo.ContentsSpecialFields);
+
+            // Split the values
+            string[] splitComments = info.CommonDiscInfo.Comments.Split('\n');
+            string[] splitContents = info.CommonDiscInfo.Contents.Split('\n');
+
+            // Validate the lines
+            Assert.Single(splitComments);
+            Assert.Equal(2, splitContents.Length);
+        }
+
+        [Fact]
+        public void ProcessSpecialFieldsNullDictionariesTest()
+        {
+            // Create a new SubmissionInfo object
+            var info = new SubmissionInfo()
+            {
+                CommonDiscInfo = new CommonDiscInfoSection()
+                {
+                    Comments = "This is a comments line\n[T:ISBN] ISBN Value",
+                    CommentsSpecialFields = null,
+
+                    Contents = "This is a contents line\n[T:GF] Game Footage",
+                    ContentsSpecialFields = null,
+                }
+            };
+
+            // Process the special fields
+            Formatter.ProcessSpecialFields(info);
+
+            // Validate the basics
+            Assert.NotNull(info.CommonDiscInfo.Comments);
+            Assert.Null(info.CommonDiscInfo.CommentsSpecialFields);
+            Assert.NotNull(info.CommonDiscInfo.Contents);
+            Assert.Null(info.CommonDiscInfo.ContentsSpecialFields);
+
+            // Split the values
+            string[] splitComments = info.CommonDiscInfo.Comments.Split('\n');
+            string[] splitContents = info.CommonDiscInfo.Contents.Split('\n');
+
+            // Validate the lines
+            Assert.Equal(2, splitComments.Length);
+            Assert.Equal(2, splitContents.Length);
+        }
+    }
+}

MPF.Frontend.Test/Tools/ProtectionToolTests.cs

@@ -0,0 +1,809 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MPF.Frontend.Tools;
+using Xunit;
+
+namespace MPF.Frontend.Test.Tools
+{
+    public class ProtectionToolTests
+    {
+        #region SanitizeContextSensitiveProtections
+
+        [Fact]
+        public void SanitizeContextSensitiveProtections_Empty_NoException()
+        {
+            Dictionary<string, List<string>>? protections = [];
+            var actual = ProtectionTool.SanitizeContextSensitiveProtections(protections);
+            Assert.NotNull(actual);
+            Assert.Empty(actual);
+        }
+
+        [Fact]
+        public void SanitizeContextSensitiveProtections_NoMatch_NoChange()
+        {
+            Dictionary<string, List<string>>? protections = [];
+            protections["File1"] = ["Protection 1", "Protection 2"];
+
+            var actual = ProtectionTool.SanitizeContextSensitiveProtections(protections);
+            Assert.NotNull(actual);
+
+            string[] keys = [.. actual.Keys];
+            Assert.Contains("File1", keys);
+        }
+
+        [Fact]
+        public void SanitizeContextSensitiveProtections_Match_NoSub_NoChange()
+        {
+            Dictionary<string, List<string>>? protections = [];
+            protections["File1"] = ["Protection 1", "Protection 2"];
+            protections["File2"] = ["SecuROM Release Control - ANYTHING", "Protection 2"];
+            protections["File3"] = ["Protection 1", "SecuROM Release Control -"];
+
+            var actual = ProtectionTool.SanitizeContextSensitiveProtections(protections);
+            Assert.NotNull(actual);
+
+            string[] keys = [.. actual.Keys];
+            Assert.Contains("File1", keys);
+            Assert.Contains("File2", keys);
+            Assert.Contains("File3", keys);
+        }
+
+        [Fact]
+        public void SanitizeContextSensitiveProtections_Match_Sub_Change()
+        {
+            Dictionary<string, List<string>>? protections = [];
+            protections["File1"] = ["Protection 1", "Protection 2"];
+            protections["File2"] = ["SecuROM Release Control - ANYTHING"];
+            protections["File2/FileA"] = ["ANYTHING GitHub ANYTHING"];
+            protections["File2/FileB"] = ["SecuROM 7"];
+            protections["File2/FileC"] = ["SecuROM 8"];
+            protections["File2/FileD"] = ["SecuROM Content Activation"];
+            protections["File2/FileE"] = ["SecuROM Data File Activation"];
+            protections["File2/FileF"] = ["Unlock"];
+
+            var actual = ProtectionTool.SanitizeContextSensitiveProtections(protections);
+            Assert.NotNull(actual);
+
+            string[] keys = [.. actual.Keys];
+            Assert.Contains("File1", keys);
+            Assert.Contains("File2", keys);
+            Assert.Contains("File2/FileA", keys);
+            Assert.DoesNotContain("File2/FileB", keys);
+            Assert.DoesNotContain("File2/FileC", keys);
+            Assert.DoesNotContain("File2/FileD", keys);
+            Assert.DoesNotContain("File2/FileE", keys);
+            Assert.DoesNotContain("File2/FileF", keys);
+        }
+
+        [Fact]
+        public void SanitizeContextSensitiveProtections_MultiMatch_Sub_Change()
+        {
+            Dictionary<string, List<string>>? protections = [];
+            protections["File1"] = ["Protection 1", "Protection 2"];
+            protections["File2"] = ["SecuROM Release Control - ANYTHING"];
+            protections["File2/FileA"] = ["ANYTHING GitHub ANYTHING"];
+            protections["File2/FileB"] = ["SecuROM 7"];
+            protections["File2/FileC"] = ["SecuROM 8"];
+            protections["File3"] = ["SecuROM Release Control - ANYTHING"];
+            protections["File3/FileD"] = ["SecuROM Content Activation"];
+            protections["File3/FileE"] = ["SecuROM Data File Activation"];
+            protections["File3/FileF"] = ["Unlock"];
+
+            var actual = ProtectionTool.SanitizeContextSensitiveProtections(protections);
+            Assert.NotNull(actual);
+
+            string[] keys = [.. actual.Keys];
+            Assert.Contains("File1", keys);
+            Assert.Contains("File2", keys);
+            Assert.Contains("File2/FileA", keys);
+            Assert.DoesNotContain("File2/FileB", keys);
+            Assert.DoesNotContain("File2/FileC", keys);
+            Assert.Contains("File3", keys);
+            Assert.DoesNotContain("File3/FileD", keys);
+            Assert.DoesNotContain("File3/FileE", keys);
+            Assert.DoesNotContain("File3/FileF", keys);
+        }
+
+        #endregion
+
+        #region SanitizeFoundProtections
+
+        [Fact]
+        public void SanitizeFoundProtections_Exception()
+        {
+            List<string> protections =
+            [
+                "Anything Else Protection",
+                "[Access issue when opening file",
+                "[Exception opening file",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("Anything Else Protection, Exception occurred while scanning [RESCAN NEEDED]", sanitized);
+        }
+
+        #region Game Engine
+
+        [Fact]
+        public void SanitizeFoundProtections_RenderWare()
+        {
+            List<string> protections =
+            [
+                "RenderWare",
+                "RenderWare ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        #endregion
+
+        #region Packers
+
+        [Fact]
+        public void SanitizeFoundProtections_dotNetReactor()
+        {
+            List<string> protections =
+            [
+                ".NET Reactor",
+                ".NET Reactor ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_SevenZipSFX()
+        {
+            List<string> protections =
+            [
+                "7-Zip SFX",
+                "7-Zip SFX ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_ASPack()
+        {
+            List<string> protections =
+            [
+                "ASPack",
+                "ASPack ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_AutoPlayMediaStudio()
+        {
+            List<string> protections =
+            [
+                "AutoPlay Media Studio",
+                "AutoPlay Media Studio ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_CaphyonAdvancedInstaller()
+        {
+            List<string> protections =
+            [
+                "Caphyon Advanced Installer",
+                "Caphyon Advanced Installer ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_CExe()
+        {
+            List<string> protections =
+            [
+                "CExe",
+                "CExe ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_dotFuscator()
+        {
+            List<string> protections =
+            [
+                "dotFuscator",
+                "dotFuscator ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_EmbeddedArchive()
+        {
+            List<string> protections =
+            [
+                "Embedded 7-zip Archive",
+                "Embedded PKZIP Archive",
+                "Embedded RAR Archive",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_EmbeddedExecutable()
+        {
+            List<string> protections =
+            [
+                "Embedded Executable",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_EXEStealth()
+        {
+            List<string> protections =
+            [
+                "EXE Stealth",
+                "EXE Stealth ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_GenteeInstaller()
+        {
+            List<string> protections =
+            [
+                "Gentee Installer",
+                "Gentee Installer ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_HyperTechCrackProof()
+        {
+            List<string> protections =
+            [
+                "HyperTech CrackProof",
+                "HyperTech CrackProof ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_InnoSetup()
+        {
+            List<string> protections =
+            [
+                "Inno Setup",
+                "Inno Setup ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_InstallAnywhere()
+        {
+            List<string> protections =
+            [
+                "InstallAnywhere",
+                "InstallAnywhere ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_InstallerVISE()
+        {
+            List<string> protections =
+            [
+                "Installer VISE",
+                "Installer VISE ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_IntelInstallationFramework()
+        {
+            List<string> protections =
+            [
+                "Intel Installation Framework",
+                "Intel Installation Framework ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_MicrosoftCABSFX()
+        {
+            List<string> protections =
+            [
+                "Microsoft CAB SFX",
+                "Microsoft CAB SFX ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_NeoLite()
+        {
+            List<string> protections =
+            [
+                "NeoLite",
+                "NeoLite ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_NSIS()
+        {
+            List<string> protections =
+            [
+                "NSIS",
+                "NSIS ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_PECompact()
+        {
+            List<string> protections =
+            [
+                "PE Compact",
+                "PE Compact ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_PEtite()
+        {
+            List<string> protections =
+            [
+                "PEtite",
+                "PEtite ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_SetupFactory()
+        {
+            List<string> protections =
+            [
+                "Setup Factory",
+                "Setup Factory ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_Shrinker()
+        {
+            List<string> protections =
+            [
+                "Shrinker",
+                "Shrinker ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_UPX()
+        {
+            List<string> protections =
+            [
+                "UPX",
+                "UPX ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_WinRARSFX()
+        {
+            List<string> protections =
+            [
+                "WinRAR SFX",
+                "WinRAR SFX ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_WinZipSFX()
+        {
+            List<string> protections =
+            [
+                "WinZip SFX",
+                "WinZip SFX ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_WiseInstaller()
+        {
+            List<string> protections =
+            [
+                "Wise Installation",
+                "Wise Installation ANYTHING",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        #endregion
+
+        #region Protections
+
+        [Fact]
+        public void SanitizeFoundProtections_ActiveMARK()
+        {
+            List<string> protections =
+            [
+                "ActiveMARK",
+                "ActiveMARK 5",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("ActiveMARK 5", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_CactusDataShield()
+        {
+            List<string> protections =
+            [
+                "Cactus Data Shield 200",
+                "Cactus Data Shield 200 (Build 3.0.100a)",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("Cactus Data Shield 200 (Build 3.0.100a)", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_CactusDataShieldMacrovision()
+        {
+            List<string> protections =
+            [
+                "Anything Else Protection",
+                "Cactus Data Shield 300 (Confirm presence of other CDS-300 files)",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("Anything Else Protection, Cactus Data Shield 300", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_CDCheck()
+        {
+            List<string> protections =
+            [
+                "Anything Else Protection",
+                "Executable-Based CD Check",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("Anything Else Protection", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_CDCops()
+        {
+            List<string> protections =
+            [
+                "CD-Cops",
+                "CD-Cops v1.2.0",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("CD-Cops v1.2.0", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_CDKey()
+        {
+            List<string> protections =
+            [
+                "Anything Else Protection",
+                "CD-Key / Serial",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("Anything Else Protection", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_EACdKey()
+        {
+            List<string> protections =
+            [
+                "EA CdKey Registration Module",
+                "EA CdKey Registration Module v1.2.0",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Empty(sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_EADRM()
+        {
+            List<string> protections =
+            [
+                "EA DRM Protection",
+                "EA DRM Protection v1.2.0",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("EA DRM Protection v1.2.0", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_GFWL()
+        {
+            List<string> protections =
+            [
+                "Games for Windows LIVE",
+                "Games for Windows LIVE v1.2.0",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("Games for Windows LIVE v1.2.0", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_GFWLZDPP()
+        {
+            List<string> protections =
+            [
+                "Games for Windows LIVE",
+                "Games for Windows LIVE Zero Day Piracy Protection",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("Games for Windows LIVE, Games for Windows LIVE Zero Day Piracy Protection", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_ImpulseReactor()
+        {
+            List<string> protections =
+            [
+                "Impulse Reactor",
+                "Impulse Reactor Core Module v1.2.0",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("Impulse Reactor Core Module v1.2.0", sanitized);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        public void SanitizeFoundProtections_JoWoodXProtTest(int skip)
+        {
+            List<string> protections =
+            [
+                "JoWood X-Prot 1.2.0.00",
+                "JoWood X-Prot v2",
+                "JoWood X-Prot v1.4+",
+                "JoWood X-Prot v1.0-v1.3",
+                "JoWood X-Prot",
+            ];
+
+            // Safeguard for the future
+            if (skip >= protections.Count)
+                throw new ArgumentException("Invalid skip value", nameof(skip));
+
+            // The list is in order of preference
+            protections = protections.Skip(skip).ToList();
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal(protections[0], sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_OnlineRegistration()
+        {
+            List<string> protections =
+            [
+                "Anything Else Protection",
+                "Executable-Based Online Registration",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("Anything Else Protection", sanitized);
+        }
+
+        [Theory]
+        [InlineData(0, "Macrovision Protected Application [SafeDisc 0.00.000], SafeDisc 0.00.000, SafeDisc Lite")]
+        [InlineData(1, "Macrovision Protected Application [SafeDisc 0.00.000 / SRV Tool APP], SafeDisc 0.00.000, SafeDisc Lite")]
+        [InlineData(2, "SafeDisc 0.00.000, SafeDisc 0.00.000-1.11.111, SafeDisc 3+ (DVD), SafeDisc Lite")]
+        [InlineData(3, "SafeDisc 0.00.000, SafeDisc 3+ (DVD), SafeDisc Lite")]
+        [InlineData(4, "SafeDisc 3+ (DVD), SafeDisc Lite")]
+        [InlineData(5, "Macrovision Security Driver, SafeDisc Lite")]
+        [InlineData(6, "Macrovision Protection File, SafeDisc 2+, SafeDisc 3+ (DVD), SafeDisc Lite")]
+        [InlineData(7, "SafeDisc 3+ (DVD)")]
+        [InlineData(8, "SafeDisc 2+")]
+        public void SanitizeFoundProtections_SafeDisc(int skip, string expected)
+        {
+            List<string> protections =
+           [
+                "Macrovision Protected Application [SafeDisc 0.00.000]",
+                "Macrovision Protected Application [SafeDisc 0.00.000 / SRV Tool APP]",
+                "SafeDisc 0.00.000-1.11.111",
+                "SafeDisc 0.00.000",
+                "Macrovision Security Driver 1.11.111 / SafeDisc 1.11.111",
+                "Macrovision Security Driver",
+                "SafeDisc Lite",
+                "SafeDisc 3+ (DVD)",
+                "SafeDisc 2+",
+                "Macrovision Protection File",
+            ];
+
+            // Safeguard for the future
+            if (skip >= protections.Count)
+                throw new ArgumentException("Invalid skip value", nameof(skip));
+
+            // The list is in order of preference
+            protections = protections.Skip(skip).ToList();
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal(expected, sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtectsion_SafeDisc_MacrovisionSecurityDriver()
+        {
+            List<string> protections =
+           [
+                "Macrovision Protection File [Likely indicates either SafeDisc 1.45.011+ (CD) or CDS-300]",
+                "Macrovision Security Driver 4.00.060 / SafeDisc 4.00.000-4.70.000",
+                "SafeDisc 4.00.000-4.00.003",
+                "SafeDisc 4.00.002, Macrovision Protected Application"
+            ];
+
+            string expected = "SafeDisc 4.00.002";
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal(expected, sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_SecuROM()
+        {
+            List<string> protections =
+            [
+                "SecuROM Release Control",
+                "SecuROM Release Control - ANYTHING",
+                "SecuROM Release Control - ANYTHING ELSE",
+                "SecuROM Release Control - EVEN MORE",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("SecuROM Release Control", sanitized);
+        }
+
+        [Theory]
+        [InlineData(0)]
+        [InlineData(1)]
+        [InlineData(2)]
+        [InlineData(3)]
+        public void SanitizeFoundProtections_StarForce(int skip)
+        {
+            List<string> protections =
+            [
+                "StarForce 1.20.000.000",
+                "StarForce 5 [Protected Module]",
+                "StarForce 5",
+                "StarForce 3-5",
+                "StarForce",
+            ];
+
+            // Safeguard for the future
+            if (skip >= protections.Count)
+                throw new ArgumentException("Invalid skip value", nameof(skip));
+
+            // The list is in order of preference
+            protections = protections.Skip(skip).ToList();
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal(protections[0], sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_Sysiphus()
+        {
+            List<string> protections =
+            [
+                "Sysiphus",
+                "Sysiphus v1.2.0",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("Sysiphus v1.2.0", sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_XCP()
+        {
+            List<string> protections =
+            [
+                "XCP",
+                "XCP v1.2.0",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("XCP v1.2.0", sanitized);
+        }
+
+        #endregion
+
+        #endregion
+    }
+}

MPF.Frontend/ComboBoxItems/Element.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+
+namespace MPF.Frontend.ComboBoxItems
+{
+    /// <summary>
+    /// A generic combo box element
+    /// </summary>
+    /// <typeparam name="T">Enum type representing the possible values</typeparam>
+    public class Element<T> : IEquatable<Element<T>>, IElement where T : struct, Enum
+    {
+        private readonly T Data;
+
+        public Element(T data) => Data = data;
+
+        /// <summary>
+        /// Allow elements to be used as their internal enum type
+        /// </summary>
+        /// <param name="item"></param>
+        public static implicit operator T? (Element<T> item) => item?.Data;
+
+        /// <inheritdoc/>
+        public string Name => EnumExtensions.GetLongName(Data);
+
+        public override string ToString() => Name;
+
+        /// <summary>
+        /// Internal enum value
+        /// </summary>
+        public T Value => Data;
+
+        /// <summary>
+        /// Determine if the item is selected or not
+        /// </summary>
+        /// <remarks>Only applies to CheckBox type</remarks>
+        public bool IsChecked { get; set; }
+
+        /// <summary>
+        /// Generate all elements associated with the data enum type
+        /// </summary>
+        /// <returns></returns>
+        public static List<Element<T>> GenerateElements()
+        {
+            var enumArr = (T[])Enum.GetValues(typeof(T));
+            return [.. Array.ConvertAll(enumArr, e => new Element<T>(e))];
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(object? obj)
+        {
+            return Equals(obj as Element<T>);
+        }
+
+        /// <inheritdoc/>
+        public bool Equals(Element<T>? other)
+        {
+            if (other == null)
+                return false;
+
+            return Name == other.Name;
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode() => base.GetHashCode();
+    }
+}

MPF.Frontend/ComboBoxItems/IElement.cs

@@ -0,0 +1,10 @@
+namespace MPF.Frontend.ComboBoxItems
+{
+    public interface IElement
+    {
+        /// <summary>
+        /// Display name for the combo box element
+        /// </summary>
+        string Name { get; }
+    }
+}

MPF.Frontend/ComboBoxItems/RedumpSystemComboBoxItem.cs

@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+#if NET35_OR_GREATER || NETCOREAPP
+using System.Linq;
+#endif
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend.ComboBoxItems
+{
+    /// <summary>
+    /// Represents a single item in the System combo box
+    /// </summary>
+    public class RedumpSystemComboBoxItem : IEquatable<RedumpSystemComboBoxItem>, IElement
+    {
+        private readonly object? Data;
+
+        public RedumpSystemComboBoxItem(RedumpSystem? system) => Data = system;
+        public RedumpSystemComboBoxItem(SystemCategory? category) => Data = category;
+
+        public static implicit operator RedumpSystem?(RedumpSystemComboBoxItem item) => item.Data as RedumpSystem?;
+
+        /// <inheritdoc/>
+        public string Name
+        {
+            get
+            {
+                if (IsHeader)
+                    return "---------- " + (Data as SystemCategory?).LongName() + " ----------";
+                else
+                    return (Data as RedumpSystem?).LongName() ?? "No system selected";
+            }
+        }
+
+        public override string ToString() => Name;
+
+        /// <summary>
+        /// Internal enum value
+        /// </summary>
+        public RedumpSystem? Value => Data as RedumpSystem?;
+
+        /// <summary>
+        /// Determines if the item is a header value
+        /// </summary>
+        public bool IsHeader => Data is SystemCategory?;
+
+        /// <summary>
+        /// Determines if the item is a standard system value
+        /// </summary>
+        public bool IsSystem => Data is RedumpSystem?;
+
+        /// <summary>
+        /// Generate all elements for the known system combo box
+        /// </summary>
+        /// <returns></returns>
+        public static List<RedumpSystemComboBoxItem> GenerateElements()
+        {
+            var enumArr = (RedumpSystem[])Enum.GetValues(typeof(RedumpSystem));
+            var nullableArr = Array.ConvertAll(enumArr, s => (RedumpSystem?)s);
+            var knownSystems = Array.FindAll(nullableArr,
+                s => !s.IsMarker() && s.GetCategory() != SystemCategory.NONE);
+
+#if NET20
+            // The resulting dictionary does not have ordered value lists
+            var mapping = new Dictionary<SystemCategory, List<RedumpSystem?>>();
+            foreach (var knownSystem in knownSystems)
+            {
+                var category = knownSystem.GetCategory();
+                if (!mapping.ContainsKey(category))
+                    mapping[category] = [];
+
+                mapping[category].Add(knownSystem);
+            }
+#else
+            // The resulting dictionary has ordered value lists
+            Dictionary<SystemCategory, List<RedumpSystem?>> mapping = knownSystems
+                .GroupBy(s => s.GetCategory())
+                .ToDictionary(
+                    k => k.Key,
+                    v => v
+                        .OrderBy(s => s.LongName())
+                        .ToList()
+                );
+#endif
+
+            var systemsValues = new List<RedumpSystemComboBoxItem>
+            {
+                new RedumpSystemComboBoxItem((RedumpSystem?)null),
+            };
+
+            foreach (var group in mapping)
+            {
+                systemsValues.Add(new RedumpSystemComboBoxItem(group.Key));
+                group.Value.ForEach(system => systemsValues.Add(new RedumpSystemComboBoxItem(system)));
+            }
+
+            return systemsValues;
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(object? obj)
+        {
+            return Equals(obj as RedumpSystemComboBoxItem);
+        }
+
+        /// <inheritdoc/>
+        public bool Equals(RedumpSystemComboBoxItem? other)
+        {
+            if (other == null)
+                return false;
+
+            return Value == other.Value;
+        }
+
+        /// <inheritdoc/>
+        public override int GetHashCode() => base.GetHashCode();
+    }
+}

MPF.Frontend/ConsoleLogger.cs

@@ -0,0 +1,24 @@
+using System;
+using BinaryObjectScanner;
+
+namespace MPF.Frontend
+{
+    public static class ConsoleLogger
+    {
+        /// <summary>
+        /// Simple process counter to write to console
+        /// </summary>
+        public static void ProgressUpdated(object? sender, ResultEventArgs value)
+        {
+            Console.WriteLine(value.Message);
+        }
+
+        /// <summary>
+        /// Simple process counter to write to console
+        /// </summary>
+        public static void ProgressUpdated(object? sender, ProtectionProgress value)
+        {
+            Console.WriteLine($"{value.Percentage * 100:N2}%: {value.Filename} - {value.Protection}");
+        }
+    }
+}

MPF.Frontend/Drive.cs

@@ -0,0 +1,323 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+#if NET462_OR_GREATER || NETCOREAPP
+using Microsoft.Management.Infrastructure;
+using Microsoft.Management.Infrastructure.Generic;
+#endif
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// Represents information for a single drive
+    /// </summary>
+    /// <remarks>
+    /// TODO: Can the Aaru models be used instead of the ones I've created here?
+    /// </remarks>
+    public class Drive
+    {
+        #region Fields
+
+        /// <summary>
+        /// Represents drive type
+        /// </summary>
+        public InternalDriveType? InternalDriveType { get; set; }
+
+        /// <summary>
+        /// Drive partition format
+        /// </summary>
+        public string? DriveFormat { get; private set; } = null;
+
+        /// <summary>
+        /// Windows drive path
+        /// </summary>
+        public string? Name { get; private set; } = null;
+
+        /// <summary>
+        /// Represents if Windows has marked the drive as active
+        /// </summary>
+        public bool MarkedActive { get; private set; } = false;
+
+        /// <summary>
+        /// Represents the total size of the drive
+        /// </summary>
+        public long TotalSize { get; private set; } = default;
+
+        /// <summary>
+        /// Media label as read by Windows
+        /// </summary>
+        /// <remarks>The try/catch is needed because Windows will throw an exception if the drive is not marked as active</remarks>
+        public string? VolumeLabel { get; private set; } = null;
+
+        #endregion
+
+        #region Derived Fields
+
+        /// <summary>
+        /// Read-only access to the drive letter
+        /// </summary>
+        /// <remarks>Should only be used in UI applications</remarks>
+        public char? Letter => Name?[0] ?? '\0';
+
+        #endregion
+
+        /// <summary>
+        /// Protected constructor
+        /// </summary>
+        protected Drive() { }
+
+        /// <summary>
+        /// Create a new Drive object from a drive type and device path
+        /// </summary>
+        /// <param name="driveType">InternalDriveType value representing the drive type</param>
+        /// <param name="devicePath">Path to the device according to the local machine</param>
+        public static Drive? Create(InternalDriveType? driveType, string devicePath)
+        {
+            // Create a new, empty drive object
+            var drive = new Drive()
+            {
+                InternalDriveType = driveType,
+            };
+
+            // If we have an invalid device path, return null
+            if (string.IsNullOrEmpty(devicePath))
+                return null;
+
+            // Sanitize a Windows-formatted long device path
+            if (devicePath.StartsWith("\\\\.\\"))
+                devicePath = devicePath.Substring("\\\\.\\".Length);
+
+            // Create and validate the drive info object
+            var driveInfo = new DriveInfo(devicePath);
+            if (driveInfo == null || driveInfo == default)
+                return null;
+
+            // Fill in the rest of the data
+            drive.PopulateFromDriveInfo(driveInfo);
+
+            return drive;
+        }
+
+        /// <summary>
+        /// Populate all fields from a DriveInfo object
+        /// </summary>
+        /// <param name="driveInfo">DriveInfo object to populate from</param>
+        private void PopulateFromDriveInfo(DriveInfo? driveInfo)
+        {
+            // If we have an invalid DriveInfo, just return
+            if (driveInfo == null || driveInfo == default)
+                return;
+
+            // Populate the data fields
+            Name = driveInfo.Name;
+            MarkedActive = driveInfo.IsReady;
+            if (MarkedActive)
+            {
+                DriveFormat = driveInfo.DriveFormat;
+                TotalSize = driveInfo.TotalSize;
+                VolumeLabel = driveInfo.VolumeLabel;
+            }
+            else
+            {
+                DriveFormat = string.Empty;
+                TotalSize = default;
+                VolumeLabel = string.Empty;
+            }
+        }
+
+        #region Public Functionality
+
+        /// <summary>
+        /// Create a list of active drives matched to their volume labels
+        /// </summary>
+        /// <param name="ignoreFixedDrives">True to ignore fixed drives from population, false otherwise</param>
+        /// <returns>Active drives, matched to labels, if possible</returns>
+        public static List<Drive> CreateListOfDrives(bool ignoreFixedDrives)
+        {
+            var drives = GetDriveList(ignoreFixedDrives);
+            drives.Sort((d1, d2) =>
+            {
+                string d1Name = d1?.Name == null ? "\0" : d1.Name;
+                string d2Name = d2?.Name == null ? "\0" : d2.Name;
+                return d1Name.CompareTo(d2Name);
+            });
+            return [.. drives];
+        }
+
+        /// <summary>
+        /// Get the current media type from drive letter
+        /// </summary>
+        /// <param name="system">Currently selected system</param>
+        /// <returns>The detected media type, if possible</returns>
+        public MediaType? GetMediaType(RedumpSystem? system)
+        {
+            // Take care of the non-optical stuff first
+            switch (InternalDriveType)
+            {
+                case Frontend.InternalDriveType.Floppy:
+                    return MediaType.FloppyDisk;
+                case Frontend.InternalDriveType.HardDisk:
+                    return MediaType.HardDisk;
+                case Frontend.InternalDriveType.Removable:
+                    return MediaType.FlashDrive;
+            }
+
+            // Some systems should default to certain media types
+            switch (system)
+            {
+                // CD
+                case RedumpSystem.Panasonic3DOInteractiveMultiplayer:
+                case RedumpSystem.PhilipsCDi:
+                case RedumpSystem.SegaDreamcast:
+                case RedumpSystem.SegaSaturn:
+                case RedumpSystem.SonyPlayStation:
+                case RedumpSystem.VideoCD:
+                    return MediaType.CDROM;
+
+                // DVD
+                case RedumpSystem.DVDAudio:
+                case RedumpSystem.DVDVideo:
+                case RedumpSystem.MicrosoftXbox:
+                case RedumpSystem.MicrosoftXbox360:
+                    return MediaType.DVD;
+
+                // HD-DVD
+                case RedumpSystem.HDDVDVideo:
+                    return MediaType.HDDVD;
+
+                // Blu-ray
+                case RedumpSystem.BDVideo:
+                case RedumpSystem.MicrosoftXboxOne:
+                case RedumpSystem.MicrosoftXboxSeriesXS:
+                case RedumpSystem.SonyPlayStation3:
+                case RedumpSystem.SonyPlayStation4:
+                case RedumpSystem.SonyPlayStation5:
+                    return MediaType.BluRay;
+
+                // GameCube
+                case RedumpSystem.NintendoGameCube:
+                    return MediaType.NintendoGameCubeGameDisc;
+
+                // Wii
+                case RedumpSystem.NintendoWii:
+                    return MediaType.NintendoWiiOpticalDisc;
+
+                // WiiU
+                case RedumpSystem.NintendoWiiU:
+                    return MediaType.NintendoWiiUOpticalDisc;
+
+                // PSP
+                case RedumpSystem.SonyPlayStationPortable:
+                    return MediaType.UMD;
+            }
+
+            // Handle optical media by size and filesystem
+            if (TotalSize >= 0 && TotalSize <= 800_000_000 && (DriveFormat == "CDFS" || DriveFormat == "UDF"))
+                return MediaType.CDROM;
+            else if (TotalSize > 800_000_000 && TotalSize <= 8_540_000_000 && (DriveFormat == "CDFS" || DriveFormat == "UDF"))
+                return MediaType.DVD;
+            else if (TotalSize > 8_540_000_000)
+                return MediaType.BluRay;
+
+            return null;
+        }
+
+        /// <summary>
+        /// Refresh the current drive information based on path
+        /// </summary>
+        public void RefreshDrive()
+        {
+            var driveInfo = Array.Find(DriveInfo.GetDrives(), d => d?.Name == Name);
+            PopulateFromDriveInfo(driveInfo);
+        }
+
+        #endregion
+
+        #region Helpers
+
+        /// <summary>
+        /// Get all current attached Drives
+        /// </summary>
+        /// <param name="ignoreFixedDrives">True to ignore fixed drives from population, false otherwise</param>
+        /// <returns>List of drives, null on error</returns>
+        /// <remarks>
+        /// https://stackoverflow.com/questions/3060796/how-to-distinguish-between-usb-and-floppy-devices?utm_medium=organic&utm_source=google_rich_qa&utm_campaign=google_rich_qa
+        /// https://msdn.microsoft.com/en-us/library/aa394173(v=vs.85).aspx
+        /// </remarks>
+        private static List<Drive> GetDriveList(bool ignoreFixedDrives)
+        {
+            var desiredDriveTypes = new List<DriveType>() { DriveType.CDRom };
+            if (!ignoreFixedDrives)
+            {
+                desiredDriveTypes.Add(DriveType.Fixed);
+                desiredDriveTypes.Add(DriveType.Removable);
+            }
+
+            // TODO: Reduce reliance on `DriveInfo`
+            // https://github.com/aaru-dps/Aaru/blob/5164a154e2145941472f2ee0aeb2eff3338ecbb3/Aaru.Devices/Windows/ListDevices.cs#L66
+
+            // Create an output drive array
+            Drive[] drives = [];
+
+            // Get all standard supported drive types
+            try
+            {
+                var filteredDrives = Array.FindAll(DriveInfo.GetDrives(), d => desiredDriveTypes.Contains(d.DriveType));
+                drives = Array.ConvertAll(filteredDrives, d => Create(ToInternalDriveType(d.DriveType), d.Name) ?? new Drive());
+            }
+            catch
+            {
+                return [.. drives];
+            }
+
+            // Find and update all floppy drives
+#if NET462_OR_GREATER || NETCOREAPP
+            try
+            {
+                CimSession session = CimSession.Create(null);
+                var collection = session.QueryInstances("root\\CIMV2", "WQL", "SELECT * FROM Win32_LogicalDisk");
+
+                foreach (CimInstance instance in collection)
+                {
+                    CimKeyedCollection<CimProperty> properties = instance.CimInstanceProperties;
+                    uint? mediaType = properties["MediaType"]?.Value as uint?;
+                    if (mediaType != null && ((mediaType > 0 && mediaType < 11) || (mediaType > 12 && mediaType < 22)))
+                    {
+                        char devId = (properties["Caption"].Value as string ?? string.Empty)[0];
+                        Array.ForEach(drives, d =>
+                        {
+                            if (d?.Name != null && d.Name[0] == devId)
+                                d.InternalDriveType = Frontend.InternalDriveType.Floppy;
+                        });
+                    }
+                }
+            }
+            catch
+            {
+                // No-op
+            }
+#endif
+
+            return [.. drives];
+        }
+
+        /// <summary>
+        /// Convert drive type to internal version, if possible
+        /// </summary>
+        /// <param name="driveType">DriveType value to check</param>
+        /// <returns>InternalDriveType, if possible, null on error</returns>
+        internal static InternalDriveType? ToInternalDriveType(DriveType driveType)
+        {
+            return driveType switch
+            {
+                DriveType.CDRom => (InternalDriveType?)Frontend.InternalDriveType.Optical,
+                DriveType.Fixed => (InternalDriveType?)Frontend.InternalDriveType.HardDisk,
+                DriveType.Removable => (InternalDriveType?)Frontend.InternalDriveType.Removable,
+                _ => null,
+            };
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/DumpEnvironment.cs

@@ -0,0 +1,839 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
+using System.Text;
+using System.Threading.Tasks;
+using BinaryObjectScanner;
+using MPF.ExecutionContexts;
+using MPF.Frontend.Tools;
+using MPF.Processors;
+using Newtonsoft.Json;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+using Formatting = Newtonsoft.Json.Formatting;
+
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// Represents the state of all settings to be used during dumping
+    /// </summary>
+    public class DumpEnvironment
+    {
+        #region Output paths
+
+        /// <summary>
+        /// Base output file path to write files to
+        /// </summary>
+        public string OutputPath { get; private set; }
+
+        #endregion
+
+        #region UI information
+
+        /// <summary>
+        /// Drive object representing the current drive
+        /// </summary>
+        private Drive? _drive;
+
+        /// <summary>
+        /// ExecutionContext object representing how to invoke the internal program
+        /// </summary>
+        private BaseExecutionContext? _executionContext;
+
+        /// <summary>
+        /// Currently selected dumping program
+        /// </summary>
+        private readonly InternalProgram _internalProgram;
+
+        /// <summary>
+        /// Options object representing user-defined options
+        /// </summary>
+        private readonly Options _options;
+
+        /// <summary>
+        /// Processor object representing how to process the outputs
+        /// </summary>
+        private BaseProcessor? _processor;
+
+        /// <summary>
+        /// Currently selected system
+        /// </summary>
+        private readonly RedumpSystem? _system;
+
+        #endregion
+
+        #region Passthrough Fields
+
+        /// <inheritdoc cref="BaseExecutionContext.InputPath"/>
+        public string? ContextInputPath => _executionContext?.InputPath;
+
+        /// <inheritdoc cref="BaseExecutionContext.OutputPath"/>
+        public string? ContextOutputPath => _executionContext?.OutputPath;
+
+        /// <inheritdoc cref="Drive.MarkedActive/>
+        public bool DriveMarkedActive => _drive?.MarkedActive ?? false;
+
+        /// <inheritdoc cref="Drive.Name/>
+        public string? DriveName => _drive?.Name;
+
+        /// <inheritdoc cref="BaseExecutionContext.Speed"/>
+        public int? Speed
+        {
+            get => _executionContext?.Speed;
+            set
+            {
+                if (_executionContext != null)
+                    _executionContext.Speed = value;
+            }
+        }
+
+        /// <inheritdoc cref="Extensions.LongName(RedumpSystem?)/>
+        public string? SystemName => _system.LongName();
+
+        #endregion
+
+        #region Event Handlers
+
+        /// <summary>
+        /// Generic way of reporting a message
+        /// </summary>
+        public EventHandler<StringEventArgs>? ReportStatus;
+
+        #endregion
+
+        /// <summary>
+        /// Constructor for a full DumpEnvironment object from user information
+        /// </summary>
+        /// <param name="options"></param>
+        /// <param name="outputPath"></param>
+        /// <param name="drive"></param>
+        /// <param name="system"></param>
+        /// <param name="internalProgram"></param>
+        public DumpEnvironment(Options options,
+            string? outputPath,
+            Drive? drive,
+            RedumpSystem? system,
+            InternalProgram? internalProgram)
+        {
+            // Set options object
+            _options = options;
+
+            // Output paths
+            OutputPath = FrontendTool.NormalizeOutputPaths(outputPath, false);
+
+            // UI information
+            _drive = drive;
+            _system = system ?? options.DefaultSystem;
+            _internalProgram = internalProgram ?? options.InternalProgram;
+        }
+
+        #region Internal Program Management
+
+        /// <summary>
+        /// Check output path for matching logs from all dumping programs
+        /// </summary>
+        public InternalProgram? CheckForMatchingProgram(MediaType? mediaType, string? outputDirectory, string outputFilename)
+        {
+            // If a complete dump exists from a different program
+            InternalProgram? programFound = null;
+            if (programFound == null && _internalProgram != InternalProgram.Redumper)
+            {
+                var processor = new Processors.Redumper(_system);
+                var missingFiles = processor.FoundAllFiles(mediaType, outputDirectory, outputFilename);
+                if (missingFiles.Count == 0)
+                    programFound = InternalProgram.Redumper;
+            }
+            if (programFound == null && _internalProgram != InternalProgram.DiscImageCreator)
+            {
+                var processor = new Processors.DiscImageCreator(_system);
+                var missingFiles = processor.FoundAllFiles(mediaType, outputDirectory, outputFilename);
+                if (missingFiles.Count == 0)
+                    programFound = InternalProgram.DiscImageCreator;
+            }
+            if (programFound == null && _internalProgram != InternalProgram.Aaru)
+            {
+                var processor = new Processors.Aaru(_system);
+                var missingFiles = processor.FoundAllFiles(mediaType, outputDirectory, outputFilename);
+                if (missingFiles.Count == 0)
+                    programFound = InternalProgram.Aaru;
+            }
+
+            return programFound;
+        }
+
+        /// <summary>
+        /// Check output path for partial logs from all dumping programs
+        /// </summary>
+        public InternalProgram? CheckForPartialProgram(MediaType? mediaType, string? outputDirectory, string outputFilename)
+        {
+            // If a complete dump exists from a different program
+            InternalProgram? programFound = null;
+            if (programFound == null && _internalProgram != InternalProgram.Redumper)
+            {
+                var processor = new Processors.Redumper(_system);
+                if (processor.FoundAnyFiles(mediaType, outputDirectory, outputFilename))
+                    programFound = InternalProgram.Redumper;
+            }
+            if (programFound == null && _internalProgram != InternalProgram.DiscImageCreator)
+            {
+                var processor = new Processors.DiscImageCreator(_system);
+                if (processor.FoundAnyFiles(mediaType, outputDirectory, outputFilename))
+                    programFound = InternalProgram.DiscImageCreator;
+            }
+            if (programFound == null && _internalProgram != InternalProgram.Aaru)
+            {
+                var processor = new Processors.Aaru(_system);
+                if (processor.FoundAnyFiles(mediaType, outputDirectory, outputFilename))
+                    programFound = InternalProgram.Aaru;
+            }
+
+            return programFound;
+        }
+
+        /// <summary>
+        /// Set the parameters object based on the internal program and parameters string
+        /// </summary>
+        /// <param name="mediaType">MediaType for specialized dumping parameters</param>
+        /// <param name="parameters">String representation of the parameters</param>
+        public bool SetExecutionContext(MediaType? mediaType, string? parameters)
+        {
+            _executionContext = _internalProgram switch
+            {
+                InternalProgram.Aaru => new ExecutionContexts.Aaru.ExecutionContext(parameters) { ExecutablePath = _options.AaruPath },
+                InternalProgram.DiscImageCreator => new ExecutionContexts.DiscImageCreator.ExecutionContext(parameters) { ExecutablePath = _options.DiscImageCreatorPath },
+                InternalProgram.Redumper => new ExecutionContexts.Redumper.ExecutionContext(parameters) { ExecutablePath = _options.RedumperPath },
+
+                // If no dumping program found, set to null
+                InternalProgram.NONE => null,
+                _ => null,
+            };
+
+            // Set system, type, and drive
+            if (_executionContext != null)
+            {
+                _executionContext.RedumpSystem = _system;
+                _executionContext.MediaType = mediaType;
+
+                // Set some parameters, if not already set
+                OutputPath ??= _executionContext.OutputPath!;
+                _drive ??= Drive.Create(InternalDriveType.Optical, _executionContext.InputPath!);
+            }
+
+            return _executionContext != null;
+        }
+
+        /// <summary>
+        /// Set the processor object based on the internal program
+        /// </summary>
+        public bool SetProcessor()
+        {
+            _processor = _internalProgram switch
+            {
+                InternalProgram.Aaru => new Processors.Aaru(_system),
+                InternalProgram.CleanRip => new CleanRip(_system),
+                InternalProgram.DiscImageCreator => new DiscImageCreator(_system),
+                InternalProgram.PS3CFW => new PS3CFW(_system),
+                InternalProgram.Redumper => new Redumper(_system),
+                InternalProgram.UmdImageCreator => new UmdImageCreator(_system),
+                InternalProgram.XboxBackupCreator => new XboxBackupCreator(_system),
+
+                // If no dumping program found, set to null
+                InternalProgram.NONE => null,
+                _ => null,
+            };
+
+            return _processor != null;
+        }
+
+        /// <summary>
+        /// Get the full parameter string for either DiscImageCreator or Aaru
+        /// </summary>
+        /// <param name="mediaType">MediaType for specialized dumping parameters</param>
+        /// <param name="driveSpeed">Nullable int representing the drive speed</param>
+        /// <returns>String representing the params, null on error</returns>
+        public string? GetFullParameters(MediaType? mediaType, int? driveSpeed)
+        {
+            // Populate with the correct params for inputs (if we're not on the default option)
+            if (_system != null && mediaType != MediaType.NONE)
+            {
+                // If drive letter is invalid, skip this
+                if (_drive == null)
+                    return null;
+
+                // Set the proper parameters
+                _executionContext = _internalProgram switch
+                {
+                    InternalProgram.Aaru => new ExecutionContexts.Aaru.ExecutionContext(_system, mediaType, _drive.Name, OutputPath, driveSpeed, _options.Settings),
+                    InternalProgram.DiscImageCreator => new ExecutionContexts.DiscImageCreator.ExecutionContext(_system, mediaType, _drive.Name, OutputPath, driveSpeed, _options.Settings),
+                    InternalProgram.Redumper => new ExecutionContexts.Redumper.ExecutionContext(_system, mediaType, _drive.Name, OutputPath, driveSpeed, _options.Settings),
+
+                    // If no dumping program found, set to null
+                    InternalProgram.NONE => null,
+                    _ => null,
+                };
+
+                // Generate and return the param string
+                return _executionContext?.GenerateParameters();
+            }
+
+            return null;
+        }
+
+        #endregion
+
+        #region Passthrough Functionality
+
+        /// <inheritdoc cref="Extensions.DetectedByWindows(RedumpSystem?)"/>
+        public bool DetectedByWindows() => _system.DetectedByWindows();
+
+        /// <summary>
+        /// Determine if the media supports drive speeds
+        /// </summary>
+        /// <param name="type">MediaType value to check</param>
+        /// <returns>True if the media has variable dumping speeds, false otherwise</returns>
+        public bool DoesSupportDriveSpeed(MediaType? mediaType)
+        {
+            return mediaType switch
+            {
+                MediaType.CDROM
+                    or MediaType.DVD
+                    or MediaType.GDROM
+                    or MediaType.HDDVD
+                    or MediaType.BluRay
+                    or MediaType.NintendoGameCubeGameDisc
+                    or MediaType.NintendoWiiOpticalDisc
+                    or MediaType.NintendoWiiUOpticalDisc => true,
+                _ => false,
+            };
+        }
+
+        /// <inheritdoc cref="BaseProcessor.FoundAllFiles(MediaType?, string?, string)"/>
+        public bool FoundAllFiles(MediaType? mediaType, string? outputDirectory, string outputFilename)
+        {
+            if (_processor == null)
+                return false;
+
+            return _processor.FoundAllFiles(mediaType, outputDirectory, outputFilename).Count == 0;
+        }
+
+        /// <inheritdoc cref="BaseProcessor.FoundAnyFiles(MediaType?, string?, string)"/>
+        public bool FoundAnyFiles(MediaType? mediaType, string? outputDirectory, string outputFilename)
+        {
+            if (_processor == null)
+                return false;
+
+            return _processor.FoundAnyFiles(mediaType, outputDirectory, outputFilename);
+        }
+
+        /// <inheritdoc cref="BaseExecutionContext.GetDefaultExtension(MediaType?)"/>
+        public string? GetDefaultExtension(MediaType? mediaType)
+        {
+            if (_executionContext == null)
+                return null;
+
+            return _executionContext.GetDefaultExtension(mediaType);
+        }
+
+        /// <inheritdoc cref="BaseExecutionContext.GetMediaType()"/>
+        public MediaType? GetMediaType()
+        {
+            if (_executionContext == null)
+                return null;
+
+            return _executionContext.GetMediaType();
+        }
+
+        /// <summary>
+        /// Verify that, given a system and a media type, they are correct
+        /// </summary>
+        public ResultEventArgs GetSupportStatus(MediaType? mediaType)
+        {
+            // No system chosen, update status
+            if (_system == null)
+                return ResultEventArgs.Failure("Please select a valid system");
+
+            // If we're on an unsupported type, update the status accordingly
+            return mediaType switch
+            {
+                // Fully supported types
+                MediaType.BluRay
+                    or MediaType.CDROM
+                    or MediaType.DVD
+                    or MediaType.FloppyDisk
+                    or MediaType.HardDisk
+                    or MediaType.CompactFlash
+                    or MediaType.SDCard
+                    or MediaType.FlashDrive
+                    or MediaType.HDDVD => ResultEventArgs.Success($"{mediaType.LongName()} ready to dump"),
+
+                // Partially supported types
+                MediaType.GDROM
+                    or MediaType.NintendoGameCubeGameDisc
+                    or MediaType.NintendoWiiOpticalDisc
+                    or MediaType.NintendoWiiUOpticalDisc => ResultEventArgs.Success($"{mediaType.LongName()} partially supported for dumping"),
+
+                // Special case for other supported tools
+                MediaType.UMD => ResultEventArgs.Failure($"{mediaType.LongName()} supported for submission info parsing"),
+
+                // Specifically unknown type
+                MediaType.NONE => ResultEventArgs.Failure($"Please select a valid media type"),
+
+                // Undumpable but recognized types
+                _ => ResultEventArgs.Failure($"{mediaType.LongName()} media are not supported for dumping"),
+            };
+        }
+
+        /// <inheritdoc cref="BaseExecutionContext.IsDumpingCommand()"/>
+        public bool IsDumpingCommand()
+        {
+            if (_executionContext == null)
+                return false;
+
+            return _executionContext.IsDumpingCommand();
+        }
+
+        /// <inheritdoc cref="Drive.RefreshDrive"/>
+        public void RefreshDrive() => _drive?.RefreshDrive();
+
+        #endregion
+
+        #region Dumping
+
+        /// <summary>
+        /// Cancel an in-progress dumping process
+        /// </summary>
+        public void CancelDumping() => _executionContext?.KillInternalProgram();
+
+        /// <summary>
+        /// Execute the initial invocation of the dumping programs
+        /// </summary>
+        /// <param name="mediaType">MediaType for specialized dumping parameters</param>
+        /// <param name="progress">Optional result progress callback</param>
+        public async Task<ResultEventArgs> Run(MediaType? mediaType, IProgress<ResultEventArgs>? progress = null)
+        {
+            // If we don't have parameters
+            if (_executionContext == null)
+                return ResultEventArgs.Failure("Error! Current configuration is not supported!");
+
+            // Build default console progress indicators if none exist
+            if (progress == null)
+            {
+                var temp = new Progress<ResultEventArgs>();
+                temp.ProgressChanged += ConsoleLogger.ProgressUpdated;
+                progress = temp;
+            }
+
+            // Check that we have the basics for dumping
+            ResultEventArgs result = IsValidForDump(mediaType);
+            if (!result)
+                return result;
+
+            // Execute internal tool
+            progress?.Report(ResultEventArgs.Success($"Executing {_internalProgram}... please wait!"));
+
+            var directoryName = Path.GetDirectoryName(OutputPath);
+            if (!string.IsNullOrEmpty(directoryName))
+                Directory.CreateDirectory(directoryName);
+
+#if NET40
+            await Task.Factory.StartNew(() => { _executionContext.ExecuteInternalProgram(); return true; });
+#else
+            await Task.Run(_executionContext.ExecuteInternalProgram);
+#endif
+            progress?.Report(ResultEventArgs.Success($"{_internalProgram} has finished!"));
+
+            return result;
+        }
+
+        /// <summary>
+        /// Verify that the current environment has a complete dump and create submission info is possible
+        /// </summary>
+        /// <param name="resultProgress">Optional result progress callback</param>
+        /// <param name="protectionProgress">Optional protection progress callback</param>
+        /// <param name="processUserInfo">Optional user prompt to deal with submission information</param>
+        /// <param name="seedInfo">A seed SubmissionInfo object that contains user data</param>
+        /// <returns>Result instance with the outcome</returns>
+        public async Task<ResultEventArgs> VerifyAndSaveDumpOutput(
+            IProgress<ResultEventArgs>? resultProgress = null,
+            IProgress<ProtectionProgress>? protectionProgress = null,
+            ProcessUserInfoDelegate? processUserInfo = null,
+            SubmissionInfo? seedInfo = null)
+        {
+            if (_processor == null)
+                return ResultEventArgs.Failure("Error! Current configuration is not supported!");
+
+            // Build default console progress indicators if none exist
+            if (resultProgress == null)
+            {
+                var temp = new Progress<ResultEventArgs>();
+                temp.ProgressChanged += ConsoleLogger.ProgressUpdated;
+                resultProgress = temp;
+            }
+            if (protectionProgress == null)
+            {
+                var temp = new Progress<ProtectionProgress>();
+                temp.ProgressChanged += ConsoleLogger.ProgressUpdated;
+                protectionProgress = temp;
+            }
+
+            resultProgress.Report(ResultEventArgs.Success("Gathering submission information... please wait!"));
+
+            // Get the output directory and filename separately
+            var outputDirectory = Path.GetDirectoryName(OutputPath);
+            var outputFilename = Path.GetFileName(OutputPath);
+
+            // Determine the media type from the processor
+            MediaType? mediaType = _processor.DetermineMediaType(outputDirectory, outputFilename);
+
+            // Extract the information from the output files
+            resultProgress.Report(ResultEventArgs.Success("Extracting output information from output files..."));
+            var submissionInfo = await SubmissionGenerator.ExtractOutputInformation(
+                OutputPath,
+                _drive,
+                _system,
+                mediaType,
+                _options,
+                _processor,
+                resultProgress,
+                protectionProgress);
+            if (submissionInfo == null)
+            {
+                resultProgress.Report(ResultEventArgs.Failure("There was an issue extracting information!"));
+                return ResultEventArgs.Failure();
+            }
+            else
+            {
+                resultProgress.Report(ResultEventArgs.Success("Extracting information complete!"));
+            }
+
+            // Inject seed submission info data, if necessary
+            if (seedInfo != null)
+            {
+                resultProgress.Report(ResultEventArgs.Success("Injecting user-supplied information..."));
+                submissionInfo = Builder.InjectSubmissionInformation(submissionInfo, seedInfo);
+                resultProgress.Report(ResultEventArgs.Success("Information injection complete!"));
+            }
+
+            // Get user-modifiable information if configured to
+            if (_options.PromptForDiscInformation && processUserInfo != null)
+            {
+                resultProgress.Report(ResultEventArgs.Success("Waiting for additional media information..."));
+                bool? filledInfo = processUserInfo.Invoke(_options, ref submissionInfo);
+                if (filledInfo == true)
+                    resultProgress.Report(ResultEventArgs.Success("Additional media information added!"));
+                else
+                    resultProgress.Report(ResultEventArgs.Success("Media information skipped!"));
+            }
+
+            // Process special fields for site codes
+            resultProgress.Report(ResultEventArgs.Success("Processing site codes..."));
+            Formatter.ProcessSpecialFields(submissionInfo!);
+            resultProgress.Report(ResultEventArgs.Success("Processing complete!"));
+
+            // Format the information for the text output
+            resultProgress.Report(ResultEventArgs.Success("Formatting information..."));
+            var formattedValues = Formatter.FormatOutputData(submissionInfo, _options.EnableRedumpCompatibility, out string? formatResult);
+            if (formattedValues == null)
+                resultProgress.Report(ResultEventArgs.Failure(formatResult));
+            else
+                resultProgress.Report(ResultEventArgs.Success(formatResult));
+
+            // Get the filename suffix for auto-generated files
+            var filenameSuffix = _options.AddFilenameSuffix ? Path.GetFileNameWithoutExtension(outputFilename) : null;
+
+            // Write the text output
+            resultProgress.Report(ResultEventArgs.Success("Writing submission information file..."));
+            bool txtSuccess = WriteOutputData(outputDirectory, filenameSuffix, formattedValues, out string txtResult);
+            if (txtSuccess)
+                resultProgress.Report(ResultEventArgs.Success(txtResult));
+            else
+                resultProgress.Report(ResultEventArgs.Failure(txtResult));
+
+            // Write the copy protection output
+            if (submissionInfo?.CopyProtection?.FullProtections != null && submissionInfo.CopyProtection.FullProtections.Count > 0)
+            {
+                if (_options.ScanForProtection)
+                {
+                    resultProgress.Report(ResultEventArgs.Success("Writing protection information file..."));
+                    bool scanSuccess = WriteProtectionData(outputDirectory, filenameSuffix, submissionInfo, _options.HideDriveLetters);
+                    if (scanSuccess)
+                        resultProgress.Report(ResultEventArgs.Success("Writing complete!"));
+                    else
+                        resultProgress.Report(ResultEventArgs.Failure("Writing could not complete!"));
+                }
+            }
+
+            // Write the JSON output, if required
+            if (_options.OutputSubmissionJSON)
+            {
+                resultProgress.Report(ResultEventArgs.Success($"Writing submission information JSON file{(_options.IncludeArtifacts ? " with artifacts" : string.Empty)}..."));
+                bool jsonSuccess = WriteOutputData(outputDirectory, filenameSuffix, submissionInfo, _options.IncludeArtifacts);
+                if (jsonSuccess)
+                    resultProgress.Report(ResultEventArgs.Success("Writing complete!"));
+                else
+                    resultProgress.Report(ResultEventArgs.Failure("Writing could not complete!"));
+            }
+
+            // Compress the logs, if required
+            if (_options.CompressLogFiles)
+            {
+                resultProgress.Report(ResultEventArgs.Success("Compressing log files..."));
+#if NET40
+                await Task.Factory.StartNew(() =>
+#else
+                await Task.Run(() =>
+#endif
+                {
+                    bool compressSuccess = _processor.CompressLogFiles(mediaType, outputDirectory, outputFilename, filenameSuffix, out string compressResult);
+                    if (compressSuccess)
+                        resultProgress.Report(ResultEventArgs.Success(compressResult));
+                    else
+                        resultProgress.Report(ResultEventArgs.Failure(compressResult));
+
+                    return compressSuccess;
+                });
+            }
+
+            // Delete unnecessary files, if required
+            if (_options.DeleteUnnecessaryFiles)
+            {
+                resultProgress.Report(ResultEventArgs.Success("Deleting unnecessary files..."));
+                bool deleteSuccess = _processor.DeleteUnnecessaryFiles(mediaType, outputDirectory, outputFilename, out string deleteResult);
+                if (deleteSuccess)
+                    resultProgress.Report(ResultEventArgs.Success(deleteResult));
+                else
+                    resultProgress.Report(ResultEventArgs.Failure(deleteResult));
+            }
+
+            // Create PS3 IRD, if required
+            if (_options.CreateIRDAfterDumping && _system == RedumpSystem.SonyPlayStation3 && mediaType == MediaType.BluRay)
+            {
+                resultProgress.Report(ResultEventArgs.Success("Creating IRD... please wait!"));
+                bool deleteSuccess = await IRDTool.WriteIRD(OutputPath, submissionInfo?.Extras?.DiscKey, submissionInfo?.Extras?.DiscID, submissionInfo?.Extras?.PIC, submissionInfo?.SizeAndChecksums?.Layerbreak, submissionInfo?.SizeAndChecksums?.CRC32);
+                if (deleteSuccess)
+                    resultProgress.Report(ResultEventArgs.Success("IRD created!"));
+                else
+                    resultProgress.Report(ResultEventArgs.Failure("Failed to create IRD"));
+            }
+
+            resultProgress.Report(ResultEventArgs.Success("Submission information process complete!"));
+            return ResultEventArgs.Success();
+        }
+
+        /// <summary>
+        /// Checks if the parameters are valid
+        /// </summary>
+        /// <returns>True if the configuration is valid, false otherwise</returns>
+        internal bool ParametersValid(MediaType? mediaType)
+        {
+            // Missing drive means it can never be valid
+            if (_drive == null)
+                return false;
+
+            bool parametersValid = _executionContext?.IsValid() ?? false;
+            bool floppyValid = !(_drive.InternalDriveType == InternalDriveType.Floppy ^ mediaType == MediaType.FloppyDisk);
+
+            // TODO: HardDisk being in the Removable category is a hack, fix this later
+            bool removableDiskValid = !((_drive.InternalDriveType == InternalDriveType.Removable || _drive.InternalDriveType == InternalDriveType.HardDisk)
+                ^ (mediaType == MediaType.CompactFlash || mediaType == MediaType.SDCard || mediaType == MediaType.FlashDrive || mediaType == MediaType.HardDisk));
+
+            return parametersValid && floppyValid && removableDiskValid;
+        }
+
+        /// <summary>
+        /// Validate the current environment is ready for a dump
+        /// </summary>
+        /// <returns>Result instance with the outcome</returns>
+        private ResultEventArgs IsValidForDump(MediaType? mediaType)
+        {
+            // Validate that everything is good
+            if (_executionContext == null || !ParametersValid(mediaType))
+                return ResultEventArgs.Failure("Error! Current configuration is not supported!");
+
+            // Fix the output paths, just in case
+            OutputPath = FrontendTool.NormalizeOutputPaths(OutputPath, false);
+
+            // Validate that the output path isn't on the dumping drive
+            if (_drive?.Name != null && OutputPath.StartsWith(_drive.Name))
+                return ResultEventArgs.Failure("Error! Cannot output to same drive that is being dumped!");
+
+            // Validate that the required program exists
+            if (!File.Exists(_executionContext.ExecutablePath))
+                return ResultEventArgs.Failure($"Error! {_executionContext.ExecutablePath} does not exist!");
+
+            // Validate that the dumping drive doesn't contain the executable
+            string fullExecutablePath = Path.GetFullPath(_executionContext.ExecutablePath!);
+            if (_drive?.Name != null && fullExecutablePath.StartsWith(_drive.Name))
+                return ResultEventArgs.Failure("Error! Cannot dump same drive that executable resides on!");
+
+            // Validate that the current configuration is supported
+            return GetSupportStatus(mediaType);
+        }
+
+        #endregion
+
+        #region Information Output
+
+        /// <summary>
+        /// Write the data to the output folder
+        /// </summary>
+        /// <param name="outputDirectory">Output folder to use as the base path</param>
+        /// <param name="filenameSuffix">Optional suffix to append to the filename</param>
+        /// <param name="lines">Preformatted string of lines to write out to the file</param>
+        /// <returns>True on success, false on error</returns>
+        private static bool WriteOutputData(string? outputDirectory, string? filenameSuffix, string? lines, out string status)
+        {
+            // Check to see if the inputs are valid
+            if (lines == null)
+            {
+                status = "No formatted data found to write!";
+                return false;
+            }
+
+            // Now write out to a generic file
+            try
+            {
+                // Get the file path
+                var path = string.Empty;
+                if (string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                    path = "!submissionInfo.txt";
+                else if (string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                    path = $"!submissionInfo_{filenameSuffix}.txt";
+                else if (!string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                    path = Path.Combine(outputDirectory, "!submissionInfo.txt");
+                else if (!string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                    path = Path.Combine(outputDirectory, $"!submissionInfo_{filenameSuffix}.txt");
+
+                using var sw = new StreamWriter(File.Open(path, FileMode.Create, FileAccess.Write), Encoding.UTF8);
+                sw.Write(lines);
+            }
+            catch (Exception ex)
+            {
+                status = $"Writing could not complete: {ex}";
+                return false;
+            }
+
+            status = "Writing complete!";
+            return true;
+        }
+
+        // MOVE TO REDUMPLIB
+        /// <summary>
+        /// Write the data to the output folder
+        /// </summary>
+        /// <param name="outputDirectory">Output folder to use as the base path</param>
+        /// <param name="filenameSuffix">Optional suffix to append to the filename</param>
+        /// <param name="info">SubmissionInfo object representing the JSON to write out to the file</param>
+        /// <param name="includedArtifacts">True if artifacts were included, false otherwise</param>
+        /// <returns>True on success, false on error</returns>
+        private static bool WriteOutputData(string? outputDirectory, string? filenameSuffix, SubmissionInfo? info, bool includedArtifacts)
+        {
+            // Check to see if the input is valid
+            if (info == null)
+                return false;
+
+            try
+            {
+                // Get the output path
+                var path = string.Empty;
+                if (string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                    path = "!submissionInfo.json";
+                else if (string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                    path = $"!submissionInfo_{filenameSuffix}.json";
+                else if (!string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                    path = Path.Combine(outputDirectory, "!submissionInfo.json");
+                else if (!string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                    path = Path.Combine(outputDirectory, $"!submissionInfo_{filenameSuffix}.json");
+
+                // Ensure the extension is correct for the output
+                if (includedArtifacts)
+                    path += ".gz";
+
+                // Create and open the output file
+                using var fs = File.Create(path);
+
+                // Create the JSON serializer
+                var serializer = new JsonSerializer { Formatting = Formatting.Indented };
+
+                // If we included artifacts, write to a GZip-compressed file
+                if (includedArtifacts)
+                {
+                    using var gs = new GZipStream(fs, CompressionMode.Compress);
+                    using var sw = new StreamWriter(gs, Encoding.UTF8);
+                    serializer.Serialize(sw, info);
+                }
+                else
+                {
+                    using var sw = new StreamWriter(fs, Encoding.UTF8);
+                    serializer.Serialize(sw, info);
+                }
+            }
+            catch
+            {
+                // We don't care what the error is
+                return false;
+            }
+
+            return true;
+        }
+
+        // MOVE TO REDUMPLIB
+        /// <summary>
+        /// Write the protection data to the output folder
+        /// </summary>
+        /// <param name="outputDirectory">Output folder to use as the base path</param>
+        /// <param name="filenameSuffix">Optional suffix to append to the filename</param>
+        /// <param name="info">SubmissionInfo object containing the protection information</param>
+        /// <param name="hideDriveLetters">True if drive letters are to be removed from output, false otherwise</param>
+        /// <returns>True on success, false on error</returns>
+        private static bool WriteProtectionData(string? outputDirectory, string? filenameSuffix, SubmissionInfo? info, bool hideDriveLetters)
+        {
+            // Check to see if the inputs are valid
+            if (info?.CopyProtection?.FullProtections == null || info.CopyProtection.FullProtections.Count == 0)
+                return true;
+
+            // Now write out to a generic file
+            try
+            {
+                var path = string.Empty;
+                if (string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                    path = "!protectionInfo.txt";
+                else if (string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                    path = $"!protectionInfo{filenameSuffix}.txt";
+                else if (!string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
+                    path = Path.Combine(outputDirectory, "!protectionInfo.txt");
+                else if (!string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
+                    path = Path.Combine(outputDirectory, $"!protectionInfo{filenameSuffix}.txt");
+
+                using var sw = new StreamWriter(File.Open(path, FileMode.Create, FileAccess.Write), Encoding.UTF8);
+
+                List<string> sortedKeys = [.. info.CopyProtection.FullProtections.Keys];
+                sortedKeys.Sort();
+
+                foreach (string key in sortedKeys)
+                {
+                    string scanPath = key;
+                    if (hideDriveLetters)
+                        scanPath = Path.DirectorySeparatorChar + key.Substring((Path.GetPathRoot(key) ?? String.Empty).Length);
+
+                    List<string>? scanResult = info.CopyProtection.FullProtections[key];
+
+                    if (scanResult == null)
+                        sw.WriteLine($"{scanPath}: None");
+                    else
+                        sw.WriteLine($"{scanPath}: {string.Join(", ", [.. scanResult])}");
+                }
+            }
+            catch
+            {
+                // We don't care what the error is
+                return false;
+            }
+
+            return true;
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/EnumExtensions.cs

@@ -0,0 +1,358 @@
+using System;
+#if NET20 || NET35
+using System.Collections.Generic;
+#else
+using System.Collections.Concurrent;
+#endif
+using System.Reflection;
+using SabreTools.RedumpLib.Data;
+using RedumperDriveType = MPF.ExecutionContexts.Redumper.DriveType;
+using RedumperReadMethod = MPF.ExecutionContexts.Redumper.ReadMethod;
+using RedumperSectorOrder = MPF.ExecutionContexts.Redumper.SectorOrder;
+
+namespace MPF.Frontend
+{
+    public static class EnumExtensions
+    {
+        #region Convert to Long Name
+
+        /// <summary>
+        /// Long name method cache
+        /// </summary>
+#if NET20 || NET35
+        private static readonly Dictionary<Type, MethodInfo?> LongNameMethods = [];
+#else
+        private static readonly ConcurrentDictionary<Type, MethodInfo?> LongNameMethods = [];
+#endif
+
+        /// <summary>
+        /// Get the string representation of a generic enumerable value
+        /// </summary>
+        /// <param name="value">Enum value to convert</param>
+        /// <returns>String representation of that value if possible, empty string on error</returns>
+        public static string GetLongName(Enum value)
+        {
+            try
+            {
+                var sourceType = value.GetType();
+                sourceType = Nullable.GetUnderlyingType(sourceType) ?? sourceType;
+
+                if (!LongNameMethods.TryGetValue(sourceType, out var method))
+                {
+                    method = typeof(Extensions).GetMethod("LongName", [typeof(Nullable<>).MakeGenericType(sourceType)]);
+                    method ??= typeof(EnumExtensions).GetMethod("LongName", [typeof(Nullable<>).MakeGenericType(sourceType)]);
+
+#if NET20 || NET35
+                    LongNameMethods[sourceType] = method;
+#else
+                    LongNameMethods.TryAdd(sourceType, method);
+#endif
+                }
+
+                if (method != null)
+                    return method.Invoke(null, [value]) as string ?? string.Empty;
+                else
+                    return string.Empty;
+            }
+            catch
+            {
+                // Converter is not implemented for the given type
+                return string.Empty;
+            }
+        }
+
+        /// <summary>
+        /// Get the string representation of the InternalProgram enum values
+        /// </summary>
+        /// <param name="prog">InternalProgram value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this InternalProgram? prog)
+        {
+            return prog switch
+            {
+                #region Dumping support
+
+                InternalProgram.Aaru => "Aaru",
+                InternalProgram.DiscImageCreator => "DiscImageCreator",
+                InternalProgram.Redumper => "Redumper",
+
+                #endregion
+
+                #region Verification support only
+
+                InternalProgram.CleanRip => "CleanRip",
+                InternalProgram.PS3CFW => "PS3 CFW",
+                InternalProgram.UmdImageCreator => "UmdImageCreator",
+                InternalProgram.XboxBackupCreator => "XboxBackupCreator",
+
+                #endregion
+
+                InternalProgram.NONE => "Unknown",
+                _ => "Unknown",
+            };
+        }
+
+        /// <summary>
+        /// Get the string representation of the RedumperReadMethod enum values
+        /// </summary>
+        /// <param name="method">RedumperReadMethod value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this RedumperReadMethod? method)
+        {
+            return method switch
+            {
+                RedumperReadMethod.D8 => "D8",
+                RedumperReadMethod.BE => "BE",
+
+                RedumperReadMethod.NONE => "Default",
+                _ => "Unknown",
+            };
+        }
+
+        /// <summary>
+        /// Get the string representation of the RedumperSectorOrder enum values
+        /// </summary>
+        /// <param name="order">RedumperSectorOrder value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this RedumperSectorOrder? order)
+        {
+            return order switch
+            {
+                RedumperSectorOrder.DATA_C2_SUB => "DATA_C2_SUB",
+                RedumperSectorOrder.DATA_SUB_C2 => "DATA_SUB_C2",
+                RedumperSectorOrder.DATA_SUB => "DATA_SUB",
+                RedumperSectorOrder.DATA_C2 => "DATA_C2",
+
+                RedumperSectorOrder.NONE => "Default",
+                _ => "Unknown",
+            };
+        }
+
+        /// <summary>
+        /// Get the string representation of the RedumperDriveType enum values
+        /// </summary>
+        /// <param name="order">RedumperDriveType value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this RedumperDriveType? type)
+        {
+            return type switch
+            {
+                RedumperDriveType.GENERIC => "GENERIC",
+                RedumperDriveType.PLEXTOR => "PLEXTOR",
+                RedumperDriveType.LG_ASU8A => "LG_ASU8A",
+                RedumperDriveType.LG_ASU8B => "LG_ASU8B",
+                RedumperDriveType.LG_ASU8C => "LG_ASU8C",
+                RedumperDriveType.LG_ASU3 => "LG_ASU3",
+                RedumperDriveType.LG_ASU2 => "LG_ASU2",
+
+                RedumperDriveType.NONE => "Default",
+                _ => "Unknown",
+            };
+        }
+
+        #endregion
+
+        #region Convert to Short Name
+
+        /// <summary>
+        /// Get the short string representation of the InternalProgram enum values
+        /// </summary>
+        /// <param name="prog">InternalProgram value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string ShortName(this InternalProgram? prog)
+        {
+            return prog switch
+            {
+                #region Dumping support
+
+                InternalProgram.Aaru => "aaru",
+                InternalProgram.DiscImageCreator => "dic",
+                InternalProgram.Redumper => "redumper",
+
+                #endregion
+
+                #region Verification support only
+
+                InternalProgram.CleanRip => "cleanrip",
+                InternalProgram.PS3CFW => "ps3cfw",
+                InternalProgram.UmdImageCreator => "uic",
+                InternalProgram.XboxBackupCreator => "xbc",
+
+                #endregion
+
+                InternalProgram.NONE => "Unknown",
+                _ => "Unknown",
+            };
+        }
+
+        #endregion
+
+        #region Convert from String
+
+        /// <summary>
+        /// Get the InternalProgram enum value for a given string
+        /// </summary>
+        /// <param name="internalProgram">String value to convert</param>
+        /// <returns>InternalProgram represented by the string, if possible</returns>
+        public static InternalProgram ToInternalProgram(this string? internalProgram)
+        {
+            return (internalProgram?.ToLowerInvariant()) switch
+            {
+                // Dumping support
+                "aaru"
+                    or "chef"
+                    or "dichef"
+                    or "discimagechef" => InternalProgram.Aaru,
+                "creator"
+                    or "dic"
+                    or "dicreator"
+                    or "discimagecreator" => InternalProgram.DiscImageCreator,
+                "rd"
+                    or "redumper" => InternalProgram.Redumper,
+
+                // Verification support only
+                "cleanrip"
+                    or "cr" => InternalProgram.CleanRip,
+                "ps3cfw"
+                    or "ps3"
+                    or "getkey"
+                    or "managunz"
+                    or "multiman" => InternalProgram.PS3CFW,
+                "uic"
+                    or "umd"
+                    or "umdcreator"
+                    or "umdimagecreator" => InternalProgram.UmdImageCreator,
+                "xbc"
+                    or "xbox"
+                    or "xbox360"
+                    or "xboxcreator"
+                    or "xboxbackupcreator" => InternalProgram.XboxBackupCreator,
+
+                _ => InternalProgram.NONE,
+            };
+        }
+
+        /// <summary>
+        /// Get the RedumperReadMethod enum value for a given string
+        /// </summary>
+        /// <param name="method">String value to convert</param>
+        /// <returns>RedumperReadMethod represented by the string, if possible</returns>
+        public static RedumperReadMethod ToRedumperReadMethod(this string? method)
+        {
+            return (method?.ToLowerInvariant()) switch
+            {
+                "d8" => RedumperReadMethod.D8,
+                "be" => RedumperReadMethod.BE,
+
+                _ => RedumperReadMethod.NONE,
+            };
+        }
+
+        /// <summary>
+        /// Get the RedumperSectorOrder enum value for a given string
+        /// </summary>
+        /// <param name="order">String value to convert</param>
+        /// <returns>RedumperSectorOrder represented by the string, if possible</returns>
+        public static RedumperSectorOrder ToRedumperSectorOrder(this string? order)
+        {
+            return (order?.ToLowerInvariant()) switch
+            {
+                "data_c2_sub"
+                    or "data c2 sub"
+                    or "data-c2-sub"
+                    or "datac2sub" => RedumperSectorOrder.DATA_C2_SUB,
+                "data_sub_c2"
+                    or "data sub c2"
+                    or "data-sub-c2"
+                    or "datasubc2" => RedumperSectorOrder.DATA_SUB_C2,
+                "data_sub"
+                    or "data sub"
+                    or "data-sub"
+                    or "datasub" => RedumperSectorOrder.DATA_SUB,
+                "data_c2"
+                    or "data c2"
+                    or "data-c2"
+                    or "datac2" => RedumperSectorOrder.DATA_C2,
+
+                _ => RedumperSectorOrder.NONE,
+            };
+        }
+
+        /// <summary>
+        /// Get the RedumperDriveType enum value for a given string
+        /// </summary>
+        /// <param name="order">String value to convert</param>
+        /// <returns>RedumperDriveType represented by the string, if possible</returns>
+        public static RedumperDriveType ToRedumperDriveType(this string? type)
+        {
+            return (type?.ToLowerInvariant()) switch
+            {
+                "generic" => RedumperDriveType.GENERIC,
+                "plextor" => RedumperDriveType.PLEXTOR,
+                "lg_asus8a"
+                    or "lg-asus8a"
+                    or "lgasus8a"
+                    or "lg_asus_8a"
+                    or "lg-asus-8a" => RedumperDriveType.LG_ASU8A,
+                "lg_asus8b"
+                    or "lg-asus8b"
+                    or "lgasus8b"
+                    or "lg_asus_8b"
+                    or "lg-asus-8b" => RedumperDriveType.LG_ASU8B,
+                "lg_asus8c"
+                    or "lg-asus8c"
+                    or "lgasus8c"
+                    or "lg_asus_8c"
+                    or "lg-asus-8c" => RedumperDriveType.LG_ASU8C,
+                "lg_asus3"
+                    or "lg-asus3"
+                    or "lgasus3"
+                    or "lg_asus_3"
+                    or "lg-asus-3" => RedumperDriveType.LG_ASU3,
+                "lg_asus2"
+                    or "lg-asus2"
+                    or "lgasus2"
+                    or "lg_asus_2"
+                    or "lg-asus-2" => RedumperDriveType.LG_ASU2,
+
+                _ => RedumperDriveType.NONE,
+            };
+        }
+
+        #endregion
+
+        #region Functionality Support
+
+        /// <summary>
+        /// Get if a system requires an anti-modchip scan
+        /// </summary>
+        public static bool SupportsAntiModchipScans(this RedumpSystem? system)
+        {
+            return system switch
+            {
+                RedumpSystem.SonyPlayStation => true,
+                _ => false,
+            };
+        }
+
+        /// <summary>
+        /// Get if a system requires a copy protection scan
+        /// </summary>
+        public static bool SupportsCopyProtectionScans(this RedumpSystem? system)
+        {
+            return system switch
+            {
+                RedumpSystem.AppleMacintosh => true,
+                RedumpSystem.EnhancedCD => true,
+                RedumpSystem.IBMPCcompatible => true,
+                RedumpSystem.PalmOS => true,
+                RedumpSystem.PocketPC => true,
+                RedumpSystem.RainbowDisc => true,
+                RedumpSystem.SonyElectronicBook => true,
+                _ => false,
+            };
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/Enumerations.cs

@@ -0,0 +1,43 @@
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// Drive type for dumping
+    /// </summary>
+    public enum InternalDriveType
+    {
+        Optical,
+        Floppy,
+        HardDisk,
+        Removable,
+    }
+
+    /// <summary>
+    /// Program that is being used to dump media
+    /// </summary>
+    public enum InternalProgram
+    {
+        NONE = 0,
+
+        // Dumping support
+        Aaru,
+        DiscImageCreator,
+        Redumper,
+
+        // Verification support only
+        CleanRip,
+        PS3CFW,
+        UmdImageCreator,
+        XboxBackupCreator,
+    }
+
+    /// <summary>
+    /// Log level for output
+    /// </summary>
+    public enum LogLevel
+    {
+        USER,
+        VERBOSE,
+        ERROR,
+        SECRET,
+    }
+}

MPF.Frontend/InterfaceConstants.cs

@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// Constant values for UI
+    /// </summary>
+    public static class InterfaceConstants
+    {
+        /// <summary>
+        /// Set of all accepted speed values
+        /// </summary>
+        private static readonly List<int> _speedValues = [0, 1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72];
+
+        /// <summary>
+        /// Set of accepted speeds for CD and GD media
+        /// </summary>
+        public static List<int> CD => _speedValues.FindAll(s => s <= 72);
+
+        /// <summary>
+        /// Set of accepted speeds for DVD media
+        /// </summary>
+        public static List<int> DVD => _speedValues.FindAll(s => s <= 24);
+
+        /// <summary>
+        /// Set of accepted speeds for HD-DVD media
+        /// </summary>
+        public static List<int> HDDVD => _speedValues.FindAll(s => s <= 24);
+
+        /// <summary>
+        /// Set of accepted speeds for BD media
+        /// </summary>
+        public static List<int> BD => _speedValues.FindAll(s => s <= 16);
+
+        /// <summary>
+        /// Get list of all drive speeds for a given MediaType
+        /// </summary>
+        /// <param name="type">MediaType? that represents the current item</param>
+        /// <returns>Read-only list of drive speeds</returns>
+        public static List<int> GetSpeedsForMediaType(MediaType? type)
+        {
+            return type switch
+            {
+                MediaType.CDROM
+                    or MediaType.GDROM => CD,
+                MediaType.DVD
+                    or MediaType.NintendoGameCubeGameDisc
+                    or MediaType.NintendoWiiOpticalDisc => DVD,
+                MediaType.HDDVD => HDDVD,
+                MediaType.BluRay
+                    or MediaType.NintendoWiiUOpticalDisc => BD,
+
+                // Default to CD speed range
+                _ => CD,
+            };
+        }
+    }
+}

MPF.Frontend/MPF.Frontend.csproj

@@ -0,0 +1,44 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <!-- Assembly Properties -->
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0</TargetFrameworks>
+        <CheckEolTargetFramework>false</CheckEolTargetFramework>
+        <IncludeSourceRevisionInInformationalVersion>false</IncludeSourceRevisionInInformationalVersion>
+        <LangVersion>latest</LangVersion>
+        <NoWarn>NU1902;NU1903</NoWarn>
+        <Nullable>enable</Nullable>
+        <SuppressTfmSupportBuildWarnings>true</SuppressTfmSupportBuildWarnings>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <VersionPrefix>3.4.1</VersionPrefix>
+
+        <!-- Package Properties -->
+        <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
+        <Description>Common code for all MPF frontend implementations</Description>
+        <Copyright>Copyright (c) Matt Nadareski 2019-2025</Copyright>
+        <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
+        <RepositoryType>git</RepositoryType>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <InternalsVisibleTo Include="MPF.Frontend.Test" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\MPF.ExecutionContexts\MPF.ExecutionContexts.csproj" />
+        <ProjectReference Include="..\MPF.Processors\MPF.Processors.csproj" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="BinaryObjectScanner" Version="3.4.2" />
+        <PackageReference Include="LibIRD" Version="1.0.0" />
+        <PackageReference Include="Microsoft.Management.Infrastructure" Version="3.0.0" Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND !$(TargetFramework.StartsWith(`net40`)) AND !$(TargetFramework.StartsWith(`net452`))" />
+        <PackageReference Include="Microsoft.Net.Http" Version="2.2.29" Condition="$(TargetFramework.StartsWith(`net452`))" />
+        <PackageReference Include="MinThreadingBridge" Version="0.11.4" Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net40`))" />
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
+        <PackageReference Include="SabreTools.RedumpLib" Version="1.7.4" />
+        <PackageReference Include="System.Net.Http" Version="4.3.4" Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND !$(TargetFramework.StartsWith(`net40`)) AND !$(TargetFramework.StartsWith(`net452`))" />
+    </ItemGroup>
+
+</Project>

MPF.Frontend/OldDotNet.cs

@@ -0,0 +1,45 @@
+#if NET20 || NET35
+using System.Collections;
+using System.Collections.Generic;
+
+namespace MPF.Frontend
+{
+    internal interface IReadOnlyCollection<T> : IEnumerable<T>
+    {
+        int Count { get; }
+    }
+
+    internal sealed class ConcurrentQueue<T> : IReadOnlyCollection<T>
+    {
+        private Queue<T> _queue = new Queue<T>();
+
+        private object _lock = new object();
+
+        public int Count => _queue.Count;
+
+        public void Enqueue(T item)
+        {
+            lock (_lock)
+            {
+                _queue.Enqueue(item);
+            }
+        }
+
+        public bool TryDequeue(out T item)
+        {
+            lock (_lock)
+            {
+                item = default(T)!;
+                if (_queue.Count == 0)
+                    return false;
+
+                item = _queue.Dequeue();
+                return true;
+            }
+        }
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator() => _queue.GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => _queue.GetEnumerator();
+    }
+}
+#endif

MPF.Frontend/Options.cs

@@ -0,0 +1,762 @@
+using System.Collections.Generic;
+using SabreTools.RedumpLib.Data;
+using AaruSettings = MPF.ExecutionContexts.Aaru.SettingConstants;
+using DICSettings = MPF.ExecutionContexts.DiscImageCreator.SettingConstants;
+using RedumperDriveType = MPF.ExecutionContexts.Redumper.DriveType;
+using RedumperReadMethod = MPF.ExecutionContexts.Redumper.ReadMethod;
+using RedumperSectorOrder = MPF.ExecutionContexts.Redumper.SectorOrder;
+using RedumperSettings = MPF.ExecutionContexts.Redumper.SettingConstants;
+
+namespace MPF.Frontend
+{
+    public class Options
+    {
+        /// <summary>
+        /// All settings in the form of a dictionary
+        /// </summary>
+        public Dictionary<string, string?> Settings { get; private set; }
+
+        /// <summary>
+        /// Indicate if the program is being run with a clean configuration
+        /// </summary>
+        public bool FirstRun
+        {
+            get { return GetBooleanSetting(Settings, "FirstRun", true); }
+            set { Settings["FirstRun"] = value.ToString(); }
+        }
+
+        #region Internal Program
+
+        /// <summary>
+        /// Path to Aaru
+        /// </summary>
+        public string? AaruPath
+        {
+            get { return GetStringSetting(Settings, "AaruPath", "Programs\\Aaru\\Aaru.exe"); }
+            set { Settings["AaruPath"] = value; }
+        }
+
+        /// <summary>
+        /// Path to DiscImageCreator
+        /// </summary>
+        public string? DiscImageCreatorPath
+        {
+            get { return GetStringSetting(Settings, "DiscImageCreatorPath", "Programs\\Creator\\DiscImageCreator.exe"); }
+            set { Settings["DiscImageCreatorPath"] = value; }
+        }
+
+        /// <summary>
+        /// Path to Redumper
+        /// </summary>
+        public string? RedumperPath
+        {
+            get { return GetStringSetting(Settings, "RedumperPath", "Programs\\Redumper\\redumper.exe"); }
+            set { Settings["RedumperPath"] = value; }
+        }
+
+        /// <summary>
+        /// Currently selected dumping program
+        /// </summary>
+        public InternalProgram InternalProgram
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "InternalProgram", InternalProgram.Redumper.ToString());
+                var valueEnum = valueString.ToInternalProgram();
+                return valueEnum == InternalProgram.NONE ? InternalProgram.Redumper : valueEnum;
+            }
+            set
+            {
+                Settings["InternalProgram"] = value.ToString();
+            }
+        }
+
+        #endregion
+
+        #region UI Defaults
+
+        /// <summary>
+        /// Enable dark mode for UI elements
+        /// </summary>
+        public bool EnableDarkMode
+        {
+            get { return GetBooleanSetting(Settings, "EnableDarkMode", false); }
+            set { Settings["EnableDarkMode"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable purple mode for UI elements
+        /// </summary>
+        /// <remarks>This is a hidden setting</remarks>
+        public bool EnablePurpMode
+        {
+            get { return GetBooleanSetting(Settings, "EnablePurpMode", false); }
+            set { Settings["EnablePurpMode"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Custom color setting
+        /// </summary>
+        /// <remarks>This is a hidden setting</remarks>
+        public string? CustomBackgroundColor
+        {
+            get { return GetStringSetting(Settings, "CustomBackgroundColor", null); }
+            set { Settings["CustomBackgroundColor"] = value; }
+        }
+
+        /// <summary>
+        /// Custom color setting
+        /// </summary>
+        /// <remarks>This is a hidden setting</remarks>
+        public string? CustomTextColor
+        {
+            get { return GetStringSetting(Settings, "CustomTextColor", null); }
+            set { Settings["CustomTextColor"] = value; }
+        }
+
+        /// <summary>
+        /// Check for updates on startup
+        /// </summary>
+        public bool CheckForUpdatesOnStartup
+        {
+            get { return GetBooleanSetting(Settings, "CheckForUpdatesOnStartup", true); }
+            set { Settings["CheckForUpdatesOnStartup"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Try to copy the update URL to the clipboard if one is found
+        /// </summary>
+        public bool CopyUpdateUrlToClipboard
+        {
+            get { return GetBooleanSetting(Settings, "CopyUpdateUrlToClipboard", true); }
+            set { Settings["CopyUpdateUrlToClipboard"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Fast update label - Skips disc checks and updates path only
+        /// </summary>
+        public bool FastUpdateLabel
+        {
+            get { return GetBooleanSetting(Settings, "FastUpdateLabel", false); }
+            set { Settings["FastUpdateLabel"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default output path for dumps
+        /// </summary>
+        public string? DefaultOutputPath
+        {
+            get { return GetStringSetting(Settings, "DefaultOutputPath", "ISO"); }
+            set { Settings["DefaultOutputPath"] = value; }
+        }
+
+        /// <summary>
+        /// Default system if none can be detected
+        /// </summary>
+        public RedumpSystem? DefaultSystem
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "DefaultSystem", RedumpSystem.IBMPCcompatible.LongName());
+                var valueEnum = Extensions.ToRedumpSystem(valueString ?? string.Empty);
+                return valueEnum;
+            }
+            set
+            {
+                Settings["DefaultSystem"] = value.LongName();
+            }
+        }
+
+        /// <summary>
+        /// Show the debug menu item
+        /// </summary>
+        /// <remarks>This is a hidden setting</remarks>
+        public bool ShowDebugViewMenuItem
+        {
+            get { return GetBooleanSetting(Settings, "ShowDebugViewMenuItem", false); }
+            set { Settings["ShowDebugViewMenuItem"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Dumping Speeds
+
+        /// <summary>
+        /// Default CD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedCD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedCD", 24); }
+            set { Settings["PreferredDumpSpeedCD"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default DVD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedDVD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedDVD", 16); }
+            set { Settings["PreferredDumpSpeedDVD"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default HD-DVD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedHDDVD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedHDDVD", 8); }
+            set { Settings["PreferredDumpSpeedHDDVD"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default BD dumping speed
+        /// </summary>
+        public int PreferredDumpSpeedBD
+        {
+            get { return GetInt32Setting(Settings, "PreferredDumpSpeedBD", 8); }
+            set { Settings["PreferredDumpSpeedBD"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Aaru
+
+        /// <summary>
+        /// Enable debug output while dumping by default
+        /// </summary>
+        public bool AaruEnableDebug
+        {
+            get { return GetBooleanSetting(Settings, AaruSettings.EnableDebug, AaruSettings.EnableDebugDefault); }
+            set { Settings[AaruSettings.EnableDebug] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable verbose output while dumping by default
+        /// </summary>
+        public bool AaruEnableVerbose
+        {
+            get { return GetBooleanSetting(Settings, AaruSettings.EnableVerbose, AaruSettings.EnableVerboseDefault); }
+            set { Settings[AaruSettings.EnableVerbose] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable force dumping of media by default
+        /// </summary>
+        public bool AaruForceDumping
+        {
+            get { return GetBooleanSetting(Settings, AaruSettings.ForceDumping, AaruSettings.ForceDumpingDefault); }
+            set { Settings[AaruSettings.ForceDumping] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of sector/subchannel rereads
+        /// </summary>
+        public int AaruRereadCount
+        {
+            get { return GetInt32Setting(Settings, AaruSettings.RereadCount, AaruSettings.RereadCountDefault); }
+            set { Settings[AaruSettings.RereadCount] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Strip personal data information from Aaru metadata by default
+        /// </summary>
+        public bool AaruStripPersonalData
+        {
+            get { return GetBooleanSetting(Settings, AaruSettings.StripPersonalData, AaruSettings.StripPersonalDataDefault); }
+            set { Settings[AaruSettings.StripPersonalData] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region DiscImageCreator
+
+        /// <summary>
+        /// Enable multi-sector read flag by default
+        /// </summary>
+        public bool DICMultiSectorRead
+        {
+            get { return GetBooleanSetting(Settings, DICSettings.MultiSectorRead, DICSettings.MultiSectorReadDefault); }
+            set { Settings[DICSettings.MultiSectorRead] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Include a default multi-sector read value
+        /// </summary>
+        public int DICMultiSectorReadValue
+        {
+            get { return GetInt32Setting(Settings, DICSettings.MultiSectorReadValue, DICSettings.MultiSectorReadValueDefault); }
+            set { Settings[DICSettings.MultiSectorReadValue] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable overly-secure dumping flags by default
+        /// </summary>
+        /// <remarks>
+        /// Split this into component parts later. Currently does:
+        /// - Scan sector protection and set subchannel read level to 2 for CD
+        /// - Set scan file protect flag for DVD
+        /// </remarks>
+        public bool DICParanoidMode
+        {
+            get { return GetBooleanSetting(Settings, DICSettings.ParanoidMode, DICSettings.ParanoidModeDefault); }
+            set { Settings[DICSettings.ParanoidMode] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable the Quiet flag by default
+        /// </summary>
+        public bool DICQuietMode
+        {
+            get { return GetBooleanSetting(Settings, DICSettings.QuietMode, DICSettings.QuietModeDefault); }
+            set { Settings[DICSettings.QuietMode] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of C2 rereads
+        /// </summary>
+        public int DICRereadCount
+        {
+            get { return GetInt32Setting(Settings, DICSettings.RereadCount, DICSettings.RereadCountDefault); }
+            set { Settings[DICSettings.RereadCount] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of DVD/HD-DVD/BD rereads
+        /// </summary>
+        public int DICDVDRereadCount
+        {
+            get { return GetInt32Setting(Settings, DICSettings.DVDRereadCount, DICSettings.DVDRereadCountDefault); }
+            set { Settings[DICSettings.DVDRereadCount] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Use the CMI flag for supported disc types
+        /// </summary>
+        public bool DICUseCMIFlag
+        {
+            get { return GetBooleanSetting(Settings, DICSettings.UseCMIFlag, DICSettings.UseCMIFlagDefault); }
+            set { Settings[DICSettings.UseCMIFlag] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Redumper
+
+        /// <summary>
+        /// Enable skeleton output while dumping by default
+        /// </summary>
+        /// <remarks>This is a hidden setting</remarks>
+        public bool RedumperEnableSkeleton
+        {
+            get { return GetBooleanSetting(Settings, RedumperSettings.EnableSkeleton, RedumperSettings.EnableSkeletonDefault); }
+            set { Settings[RedumperSettings.EnableSkeleton] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable verbose output while dumping by default
+        /// </summary>
+        public bool RedumperEnableVerbose
+        {
+            get { return GetBooleanSetting(Settings, RedumperSettings.EnableVerbose, RedumperSettings.EnableVerboseDefault); }
+            set { Settings[RedumperSettings.EnableVerbose] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Default number of redumper Plextor leadin retries
+        /// </summary>
+        public int RedumperLeadinRetryCount
+        {
+            get { return GetInt32Setting(Settings, RedumperSettings.LeadinRetryCount, RedumperSettings.LeadinRetryCountDefault); }
+            set { Settings[RedumperSettings.LeadinRetryCount] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable options incompatible with redump submissions
+        /// </summary>
+        public bool RedumperNonRedumpMode
+        {
+            get { return GetBooleanSetting(Settings, "RedumperNonRedumpMode", false); }
+            set { Settings["RedumperNonRedumpMode"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Currently selected default redumper drive type
+        /// </summary>
+        public RedumperDriveType RedumperDriveType
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, RedumperSettings.DriveType, RedumperSettings.DriveTypeDefault);
+                return valueString.ToRedumperDriveType();
+            }
+            set
+            {
+                Settings[RedumperSettings.DriveType] = value.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Currently selected default redumper read method
+        /// </summary>
+        public RedumperReadMethod RedumperReadMethod
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, RedumperSettings.ReadMethod, RedumperSettings.ReadMethodDefault);
+                return valueString.ToRedumperReadMethod();
+            }
+            set
+            {
+                Settings[RedumperSettings.ReadMethod] = value.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Currently selected default redumper sector order
+        /// </summary>
+        public RedumperSectorOrder RedumperSectorOrder
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, RedumperSettings.SectorOrder, RedumperSettings.SectorOrderDefault);
+                return valueString.ToRedumperSectorOrder();
+            }
+            set
+            {
+                Settings[RedumperSettings.SectorOrder] = value.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Default number of rereads
+        /// </summary>
+        public int RedumperRereadCount
+        {
+            get { return GetInt32Setting(Settings, RedumperSettings.RereadCount, RedumperSettings.RereadCountDefault); }
+            set { Settings[RedumperSettings.RereadCount] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable the refine sector mode flag by default
+        /// </summary>
+        public bool RedumperRefineSectorMode
+        {
+            get { return GetBooleanSetting(Settings, RedumperSettings.RefineSectorMode, RedumperSettings.RefineSectorModeDefault); }
+            set { Settings[RedumperSettings.RefineSectorMode] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Extra Dumping Options
+
+        /// <summary>
+        /// Scan the disc for protection after dumping
+        /// </summary>
+        public bool ScanForProtection
+        {
+            get { return GetBooleanSetting(Settings, "ScanForProtection", true); }
+            set { Settings["ScanForProtection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Add placeholder values in the submission info
+        /// </summary>
+        public bool AddPlaceholders
+        {
+            get { return GetBooleanSetting(Settings, "AddPlaceholders", true); }
+            set { Settings["AddPlaceholders"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Show the media information window after dumping
+        /// </summary>
+        public bool PromptForDiscInformation
+        {
+            get { return GetBooleanSetting(Settings, "PromptForDiscInformation", true); }
+            set { Settings["PromptForDiscInformation"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Pull all information from Redump if signed in
+        /// </summary>
+        public bool PullAllInformation
+        {
+            get { return GetBooleanSetting(Settings, "PullAllInformation", false); }
+            set { Settings["PullAllInformation"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Enable tabs in all input fields
+        /// </summary>
+        public bool EnableTabsInInputFields
+        {
+            get { return GetBooleanSetting(Settings, "EnableTabsInInputFields", true); }
+            set { Settings["EnableTabsInInputFields"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Limit outputs to Redump-supported values only
+        /// </summary>
+        public bool EnableRedumpCompatibility
+        {
+            get { return GetBooleanSetting(Settings, "EnableRedumpCompatibility", true); }
+            set { Settings["EnableRedumpCompatibility"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Show disc eject reminder before the media information window is shown
+        /// </summary>
+        public bool ShowDiscEjectReminder
+        {
+            get { return GetBooleanSetting(Settings, "ShowDiscEjectReminder", true); }
+            set { Settings["ShowDiscEjectReminder"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Ignore fixed drives when populating the list
+        /// </summary>
+        public bool IgnoreFixedDrives
+        {
+            get { return GetBooleanSetting(Settings, "IgnoreFixedDrives", true); }
+            set { Settings["IgnoreFixedDrives"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Add the dump filename as a suffix to the auto-generated files
+        /// </summary>
+        public bool AddFilenameSuffix
+        {
+            get { return GetBooleanSetting(Settings, "AddFilenameSuffix", false); }
+            set { Settings["AddFilenameSuffix"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Output the compressed JSON version of the submission info
+        /// </summary>
+        public bool OutputSubmissionJSON
+        {
+            get { return GetBooleanSetting(Settings, "OutputSubmissionJSON", false); }
+            set { Settings["OutputSubmissionJSON"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Include log files in serialized JSON data
+        /// </summary>
+        public bool IncludeArtifacts
+        {
+            get { return GetBooleanSetting(Settings, "IncludeArtifacts", false); }
+            set { Settings["IncludeArtifacts"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Compress output log files to reduce space
+        /// </summary>
+        public bool CompressLogFiles
+        {
+            get { return GetBooleanSetting(Settings, "CompressLogFiles", true); }
+            set { Settings["CompressLogFiles"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Delete unnecessary files to reduce space
+        /// </summary>
+        public bool DeleteUnnecessaryFiles
+        {
+            get { return GetBooleanSetting(Settings, "DeleteUnnecessaryFiles", false); }
+            set { Settings["DeleteUnnecessaryFiles"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Create a PS3 IRD file after dumping PS3 BD-ROM discs
+        /// </summary>
+        public bool CreateIRDAfterDumping
+        {
+            get { return GetBooleanSetting(Settings, "CreateIRDAfterDumping", false); }
+            set { Settings["CreateIRDAfterDumping"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Skip Options
+
+        /// <summary>
+        /// Skip detecting known system on disc scan
+        /// </summary>
+        public bool SkipSystemDetection
+        {
+            get { return GetBooleanSetting(Settings, "SkipSystemDetection", false); }
+            set { Settings["SkipSystemDetection"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Protection Scanning Options
+
+        /// <summary>
+        /// Scan archive contents during protection scanning
+        /// </summary>
+        public bool ScanArchivesForProtection
+        {
+            get { return GetBooleanSetting(Settings, "ScanArchivesForProtection", true); }
+            set { Settings["ScanArchivesForProtection"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Include debug information with scan results
+        /// </summary>
+        public bool IncludeDebugProtectionInformation
+        {
+            get { return GetBooleanSetting(Settings, "IncludeDebugProtectionInformation", false); }
+            set { Settings["IncludeDebugProtectionInformation"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Remove drive letters from protection scan output
+        /// </summary>
+        public bool HideDriveLetters
+        {
+            get { return GetBooleanSetting(Settings, "HideDriveLetters", false); }
+            set { Settings["HideDriveLetters"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Logging Options
+
+        /// <summary>
+        /// Enable verbose and debug logs to be written
+        /// </summary>
+        public bool VerboseLogging
+        {
+            get { return GetBooleanSetting(Settings, "VerboseLogging", true); }
+            set { Settings["VerboseLogging"] = value.ToString(); }
+        }
+
+        /// <summary>
+        /// Have the log panel expanded by default on startup
+        /// </summary>
+        public bool OpenLogWindowAtStartup
+        {
+            get { return GetBooleanSetting(Settings, "OpenLogWindowAtStartup", true); }
+            set { Settings["OpenLogWindowAtStartup"] = value.ToString(); }
+        }
+
+        #endregion
+
+        #region Redump Login Information
+
+        /// <summary>
+        /// Enable retrieving match information from Redump
+        /// </summary>
+        public bool RetrieveMatchInformation
+        {
+            get { return GetBooleanSetting(Settings, "RetrieveMatchInformation", true); }
+            set { Settings["RetrieveMatchInformation"] = value.ToString(); }
+        }
+
+        public string? RedumpUsername
+        {
+            get { return GetStringSetting(Settings, "RedumpUsername", ""); }
+            set { Settings["RedumpUsername"] = value; }
+        }
+
+        // TODO: Figure out a way to keep this encrypted in some way, BASE64 to start?
+        public string? RedumpPassword
+        {
+            get { return GetStringSetting(Settings, "RedumpPassword", ""); }
+            set { Settings["RedumpPassword"] = value; }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Constructor taking a dictionary for settings
+        /// </summary>
+        /// <param name="settings"></param>
+        public Options(Dictionary<string, string?>? settings = null)
+        {
+            Settings = settings ?? [];
+        }
+
+        /// <summary>
+        /// Constructor taking an existing Options object
+        /// </summary>
+        /// <param name="source"></param>
+        public Options(Options? source)
+        {
+            Settings = new Dictionary<string, string?>(source?.Settings ?? []);
+        }
+
+        /// <summary>
+        /// Accessor for the internal dictionary
+        /// </summary>
+        public string? this[string key]
+        {
+            get => Settings[key];
+            set => Settings[key] = value;
+        }
+
+        #region Helpers
+
+        /// <summary>
+        /// Get a Boolean setting from a settings, dictionary
+        /// </summary>
+        /// <param name="settings">Dictionary representing the settings</param>
+        /// <param name="key">Setting key to get a value for</param>
+        /// <param name="defaultValue">Default value to return if no value is found</param>
+        /// <returns>Setting value if possible, default value otherwise</returns>
+        internal static bool GetBooleanSetting(Dictionary<string, string?> settings, string key, bool defaultValue)
+        {
+            if (settings.ContainsKey(key))
+            {
+                if (bool.TryParse(settings[key], out bool value))
+                    return value;
+                else
+                    return defaultValue;
+            }
+            else
+            {
+                return defaultValue;
+            }
+        }
+
+        /// <summary>
+        /// Get an Int32 setting from a settings, dictionary
+        /// </summary>
+        /// <param name="settings">Dictionary representing the settings</param>
+        /// <param name="key">Setting key to get a value for</param>
+        /// <param name="defaultValue">Default value to return if no value is found</param>
+        /// <returns>Setting value if possible, default value otherwise</returns>
+        internal static int GetInt32Setting(Dictionary<string, string?> settings, string key, int defaultValue)
+        {
+            if (settings.ContainsKey(key))
+            {
+                if (int.TryParse(settings[key], out int value))
+                    return value;
+                else
+                    return defaultValue;
+            }
+            else
+            {
+                return defaultValue;
+            }
+        }
+
+        /// <summary>
+        /// Get a String setting from a settings, dictionary
+        /// </summary>
+        /// <param name="settings">Dictionary representing the settings</param>
+        /// <param name="key">Setting key to get a value for</param>
+        /// <param name="defaultValue">Default value to return if no value is found</param>
+        /// <returns>Setting value if possible, default value otherwise</returns>
+        internal static string? GetStringSetting(Dictionary<string, string?> settings, string key, string? defaultValue)
+        {
+            if (settings.ContainsKey(key))
+                return settings[key];
+            else
+                return defaultValue;
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/ProcessUserInfoDelegate.cs

@@ -0,0 +1,12 @@
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// Determines how user information is processed, if at all
+    /// </summary>
+    /// <param name="options">Options set that may impact processing</params>
+    /// <param name="info">Submission info that may be overwritten</param>
+    /// <returns>True for successful updating, false or null otherwise</returns>
+    public delegate bool? ProcessUserInfoDelegate(Options? options, ref SubmissionInfo? info);
+}

MPF.Frontend/Progress.cs

@@ -0,0 +1,108 @@
+#if NET20 || NET35 || NET40
+
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Threading;
+using System.Diagnostics;
+
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// Provides an IProgress{T} that invokes callbacks for each reported progress value.
+    /// </summary>
+    /// <typeparam name="T">Specifies the type of the progress report value.</typeparam>
+    /// <remarks>
+    /// Any handler provided to the constructor or event handlers registered with
+    /// the <see cref="ProgressChanged"/> event are invoked through a
+    /// <see cref="SynchronizationContext"/> instance captured
+    /// when the instance is constructed.  If there is no current SynchronizationContext
+    /// at the time of construction, the callbacks will be invoked on the ThreadPool.
+    /// </remarks>
+    /// <see href="https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Progress.cs"/>
+    internal class Progress<T> : IProgress<T> where T : EventArgs
+    {
+        /// <summary>The synchronization context captured upon construction.  This will never be null.</summary>
+        private readonly SynchronizationContext? _synchronizationContext;
+        /// <summary>The handler specified to the constructor.  This may be null.</summary>
+        private readonly Action<T>? _handler;
+        /// <summary>A cached delegate used to post invocation to the synchronization context.</summary>
+        private readonly SendOrPostCallback _invokeHandlers;
+
+        /// <summary>Initializes the <see cref="Progress{T}"/>.</summary>
+        public Progress()
+        {
+            // Capture the current synchronization context.
+            // If there is no current context, we use a default instance targeting the ThreadPool.
+            _synchronizationContext = SynchronizationContext.Current ?? ProgressStatics.DefaultContext;
+            Debug.Assert(_synchronizationContext != null);
+            _invokeHandlers = new SendOrPostCallback(InvokeHandlers);
+        }
+
+        /// <summary>Initializes the <see cref="Progress{T}"/> with the specified callback.</summary>
+        /// <param name="handler">
+        /// A handler to invoke for each reported progress value.  This handler will be invoked
+        /// in addition to any delegates registered with the <see cref="ProgressChanged"/> event.
+        /// Depending on the <see cref="SynchronizationContext"/> instance captured by
+        /// the <see cref="Progress{T}"/> at construction, it's possible that this handler instance
+        /// could be invoked concurrently with itself.
+        /// </param>
+        /// <exception cref="ArgumentNullException">The <paramref name="handler"/> is null (<see langword="Nothing" /> in Visual Basic).</exception>
+        public Progress(Action<T> handler) : this()
+        {
+            _handler = handler ?? throw new ArgumentNullException(nameof(handler));
+        }
+
+        /// <summary>Raised for each reported progress value.</summary>
+        /// <remarks>
+        /// Handlers registered with this event will be invoked on the
+        /// <see cref="SynchronizationContext"/> captured when the instance was constructed.
+        /// </remarks>
+        public event EventHandler<T>? ProgressChanged;
+
+        /// <summary>Reports a progress change.</summary>
+        /// <param name="value">The value of the updated progress.</param>
+        protected virtual void OnReport(T value)
+        {
+            // If there's no handler, don't bother going through the sync context.
+            // Inside the callback, we'll need to check again, in case
+            // an event handler is removed between now and then.
+            Action<T>? handler = _handler;
+            EventHandler<T>? changedEvent = ProgressChanged;
+            if (handler != null || changedEvent != null)
+            {
+                // Post the processing to the sync context.
+                // (If T is a value type, it will get boxed here.)
+                _synchronizationContext?.Post(_invokeHandlers, value);
+            }
+        }
+
+        /// <summary>Reports a progress change.</summary>
+        /// <param name="value">The value of the updated progress.</param>
+        void IProgress<T>.Report(T value) { OnReport(value); }
+
+        /// <summary>Invokes the action and event callbacks.</summary>
+        /// <param name="state">The progress value.</param>
+        private void InvokeHandlers(object? state)
+        {
+            T value = (T)state!;
+
+            Action<T>? handler = _handler;
+            EventHandler<T>? changedEvent = ProgressChanged;
+
+            handler?.Invoke(value);
+            changedEvent?.Invoke(this, value);
+        }
+    }
+
+    /// <summary>Holds static values for <see cref="Progress{T}"/>.</summary>
+    /// <remarks>This avoids one static instance per type T.</remarks>
+    internal static class ProgressStatics
+    {
+        /// <summary>A default synchronization context that targets the ThreadPool.</summary>
+        internal static readonly SynchronizationContext DefaultContext = new();
+    }
+}
+
+#endif

MPF.Frontend/ResultEventArgs.cs

@@ -0,0 +1,59 @@
+using System;
+
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// Generic success/failure result object, with optional message
+    /// </summary>
+    public class ResultEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Internal representation of success
+        /// </summary>
+        private readonly bool _success;
+
+        /// <summary>
+        /// Optional message for the result
+        /// </summary>
+        public string Message { get; }
+
+        private ResultEventArgs(bool success, string message)
+        {
+            _success = success;
+            Message = message;
+        }
+
+        /// <summary>
+        /// Create a default success result with no message
+        /// </summary>
+        public static ResultEventArgs Success() => new(true, string.Empty);
+
+        /// <summary>
+        /// Create a success result with a custom message
+        /// </summary>
+        /// <param name="message">String to add as a message</param>
+        public static ResultEventArgs Success(string? message) => new(true, message ?? string.Empty);
+
+        /// <summary>
+        /// Create a default failure result with no message
+        /// </summary>
+        /// <returns></returns>
+        public static ResultEventArgs Failure() => new(false, string.Empty);
+
+        /// <summary>
+        /// Create a failure result with a custom message
+        /// </summary>
+        /// <param name="message">String to add as a message</param>
+        public static ResultEventArgs Failure(string? message) => new(false, message ?? string.Empty);
+
+        /// <summary>
+        /// Results can be compared to boolean values based on the success value
+        /// </summary>
+        public static implicit operator bool(ResultEventArgs result) => result._success;
+
+        /// <summary>
+        /// Results can be compared to boolean values based on the success value
+        /// </summary>
+        public static implicit operator ResultEventArgs(bool bval) => new(bval, string.Empty);
+    }
+}

MPF.Frontend/StringEventArgs.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Text;
+
+namespace MPF.Frontend
+{
+    /// <summary>
+    /// String wrapper for event arguments
+    /// </summary>
+    public class StringEventArgs : EventArgs
+    {
+        /// <summary>
+        /// String represented by the event arguments
+        /// </summary>
+        private readonly string _value;
+
+        /// <summary>
+        /// Constructor for string values
+        /// </summary>
+        public StringEventArgs(string? value)
+        {
+            _value = value ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Constructor for StringBuilder values
+        /// </summary>
+        public StringEventArgs(StringBuilder? value)
+        {
+            _value = value?.ToString() ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Event arguments are just the value of the string contained within
+        /// </summary>
+        public static implicit operator string(StringEventArgs args) => args._value;
+
+        /// <summary>
+        /// Event arguments are just the value of the string contained within
+        /// </summary>
+        public static implicit operator StringBuilder(StringEventArgs args) => new(args._value);
+
+        /// <summary>
+        /// Event arguments are just the value of the string contained within
+        /// </summary>
+        public static implicit operator StringEventArgs(string? str) => new(str);
+
+        /// <summary>
+        /// Event arguments are just the value of the string contained within
+        /// </summary>
+        public static implicit operator StringEventArgs(StringBuilder? sb) => new(sb);
+    }
+}

MPF.Frontend/Tools/FrontendTool.cs

@@ -0,0 +1,669 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Text;
+using System.Text.RegularExpressions;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend.Tools
+{
+    public static class FrontendTool
+    {
+        #region Information Extraction
+
+        /// <summary>
+        /// Get the default speed for a given media type from the supplied options
+        /// </summary>
+        public static int GetDefaultSpeedForMediaType(MediaType? mediaType, Options options)
+        {
+            return mediaType switch
+            {
+                // CD dump speed
+                MediaType.CDROM => options.PreferredDumpSpeedCD,
+                MediaType.GDROM => options.PreferredDumpSpeedCD,
+
+                // DVD dump speed
+                MediaType.DVD => options.PreferredDumpSpeedDVD,
+                MediaType.NintendoGameCubeGameDisc => options.PreferredDumpSpeedDVD,
+                MediaType.NintendoWiiOpticalDisc => options.PreferredDumpSpeedDVD,
+
+                // HD-DVD dump speed
+                MediaType.HDDVD => options.PreferredDumpSpeedHDDVD,
+
+                // BD dump speed
+                MediaType.BluRay => options.PreferredDumpSpeedBD,
+                MediaType.NintendoWiiUOpticalDisc => options.PreferredDumpSpeedBD,
+
+                // Default
+                _ => options.PreferredDumpSpeedCD,
+            };
+        }
+
+        /// <summary>
+        /// Get the current system from the drive volume label
+        /// </summary>
+        /// <returns>The system based on volume label, null if none detected</returns>
+        public static RedumpSystem? GetRedumpSystemFromVolumeLabel(string? volumeLabel)
+        {
+            // If the volume label is empty, we can't do anything
+            if (string.IsNullOrEmpty(volumeLabel))
+                return null;
+
+            // Audio CD
+            if (volumeLabel!.Equals("Audio CD", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.AudioCD;
+
+            // Microsoft Xbox
+            if (volumeLabel.Equals("SEP13011042", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.MicrosoftXbox;
+            else if (volumeLabel.Equals("SEP13011042072", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.MicrosoftXbox;
+
+            // Microsoft Xbox 360
+            if (volumeLabel.Equals("XBOX360"))
+                return RedumpSystem.MicrosoftXbox360;
+            else if (volumeLabel.Equals("XGD2DVD_NTSC"))
+                return RedumpSystem.MicrosoftXbox360;
+            else if (volumeLabel.Equals("XBOX_TINYTEST"))
+                return RedumpSystem.MicrosoftXbox360;
+            else if (volumeLabel.Equals("13599"))
+                return RedumpSystem.MicrosoftXbox360;
+            else if (volumeLabel.Equals("14719"))
+                return RedumpSystem.MicrosoftXbox360;
+            else if (volumeLabel.Equals("15574"))
+                return RedumpSystem.MicrosoftXbox360;
+            else if (volumeLabel.Equals("16197"))
+                return RedumpSystem.MicrosoftXbox360;
+            else if (volumeLabel.Equals("16197"))
+                return RedumpSystem.MicrosoftXbox360;
+            else if (volumeLabel.Equals("17349"))
+                return RedumpSystem.MicrosoftXbox360;
+            // DVD_ROM and CD_ROM have too many false positives
+            //else if (volumeLabel.Equals("DVD_ROM"))
+            //    return RedumpSystem.MicrosoftXbox360;
+
+            // Sega Mega-CD / Sega-CD
+            if (volumeLabel.Equals("Sega_CD", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SegaMegaCDSegaCD;
+
+            // Sony PlayStation 3
+            if (volumeLabel.Equals("PS3VOLUME", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SonyPlayStation3;
+
+            // Sony PlayStation 4
+            if (volumeLabel.Equals("PS4VOLUME", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SonyPlayStation4;
+
+            // Sony PlayStation 5
+            if (volumeLabel.Equals("PS5VOLUME", StringComparison.OrdinalIgnoreCase))
+                return RedumpSystem.SonyPlayStation5;
+
+            return null;
+        }
+
+        #endregion
+
+        #region Normalization
+
+        /// <summary>
+        /// Adjust a disc title so that it will be processed correctly by Redump
+        /// </summary>
+        /// <param name="title">Existing title to potentially reformat</param>
+        /// <param name="languages">Array of languages to use for assuming articles</param>
+        /// <returns>The reformatted title</returns>
+        public static string? NormalizeDiscTitle(string? title, Language?[]? languages)
+        {
+            // If we have no set languages, then assume English
+            if (languages == null || languages.Length == 0)
+                languages = [Language.English];
+
+            // Loop through all of the given languages
+            foreach (var language in languages)
+            {
+                // If the new title is different, assume it was normalized and return it
+                string? newTitle = NormalizeDiscTitle(title, language);
+                if (newTitle != title)
+                    return newTitle;
+            }
+
+            // If we didn't already try English, try it now
+            if (!Array.Exists(languages, l => l == Language.English))
+                return NormalizeDiscTitle(title, Language.English);
+
+            // If all fails, then the title didn't need normalization
+            return title;
+        }
+
+        /// <summary>
+        /// Adjust a disc title so that it will be processed correctly by Redump
+        /// </summary>
+        /// <param name="title">Existing title to potentially reformat</param>
+        /// <param name="language">Language to use for assuming articles</param>
+        /// <returns>The reformatted title</returns>
+        /// <remarks>
+        /// If the language of the title is unknown or if it's multilingual,
+        /// pass in Language.English for standardized coverage.
+        /// </remarks>
+        public static string? NormalizeDiscTitle(string? title, Language? language)
+        {
+            // If we have an invalid title, just return it as-is
+            if (string.IsNullOrEmpty(title))
+                return title;
+
+            // If we have an invalid language, assume Language.English
+            if (language == null)
+                language = Language.English;
+
+            // Get the title split into parts
+            string[] splitTitle = Array.FindAll(title!.Split(' '), s => !string.IsNullOrEmpty(s));
+
+            // If we only have one part, we can't do anything
+            if (splitTitle.Length <= 1)
+                return title;
+
+            // Determine if we have a definite or indefinite article as the first item
+            string firstItem = splitTitle[0];
+            switch (firstItem.ToLowerInvariant())
+            {
+                // Latin script articles
+                case "'n"
+                    when language is Language.Manx:
+                case "a"
+                    when language is Language.English
+                        || language is Language.Hungarian
+                        || language is Language.Portuguese
+                        || language is Language.Scots:
+                case "a'"
+                    when language is Language.English
+                        || language is Language.Hungarian
+                        || language is Language.Irish
+                        || language is Language.Gaelic:     // Scottish Gaelic
+                case "al"
+                    when language is Language.Breton:
+                case "am"
+                    when language is Language.Gaelic:       // Scottish Gaelic
+                case "an"
+                    when language is Language.Breton
+                        || language is Language.Cornish
+                        || language is Language.English
+                        || language is Language.Irish
+                        || language is Language.Gaelic:     // Scottish Gaelic
+                case "anek"
+                    when language is Language.Nepali:
+                case "ar"
+                    when language is Language.Breton:
+                case "az"
+                    when language is Language.Hungarian:
+                case "ān"
+                    when language is Language.Persian:
+                case "as"
+                    when language is Language.Portuguese:
+                case "d'"
+                    when language is Language.Luxembourgish:
+                case "das"
+                    when language is Language.German:
+                case "dat"
+                    when language is Language.Luxembourgish:
+                case "de"
+                    when language is Language.Dutch:
+                case "déi"
+                    when language is Language.Luxembourgish:
+                case "dem"
+                    when language is Language.German
+                        || language is Language.Luxembourgish:
+                case "den"
+                    when language is Language.Dutch
+                        || language is Language.German
+                        || language is Language.Luxembourgish:
+                case "der"
+                    when language is Language.Dutch
+                        || language is Language.German
+                        || language is Language.Luxembourgish:
+                case "des"
+                    when language is Language.Dutch
+                        || language is Language.French
+                        || language is Language.German:
+                case "die"
+                    when language is Language.Afrikaans
+                        || language is Language.German:
+                case "du"
+                    when language is Language.French:
+                case "e"
+                    when language is Language.Papiamento:
+                case "een"
+                    when language is Language.Dutch:
+                case "egy"
+                    when language is Language.Hungarian:
+                case "ei"
+                    when language is Language.Norwegian:
+                case "ein"
+                    when language is Language.German
+                        || language is Language.Norwegian:
+                case "eine"
+                    when language is Language.German:
+                case "einem"
+                    when language is Language.German:
+                case "einen"
+                    when language is Language.German:
+                case "einer"
+                    when language is Language.German:
+                case "eines"
+                    when language is Language.German:
+                case "eit"
+                    when language is Language.Norwegian:
+                case "ek"
+                    when language is Language.Nepali:
+                case "el"
+                    when language is Language.Arabic
+                        || language is Language.Catalan
+                        || language is Language.Spanish:
+                case "els"
+                    when language is Language.Catalan:
+                case "en"
+                    when language is Language.Danish
+                        || language is Language.Luxembourgish
+                        || language is Language.Norwegian
+                        || language is Language.Swedish:
+                case "eng"
+                    when language is Language.Luxembourgish:
+                case "engem"
+                    when language is Language.Luxembourgish:
+                case "enger"
+                    when language is Language.Luxembourgish:
+                case "es"
+                    when language is Language.Catalan:
+                case "et"
+                    when language is Language.Danish
+                        || language is Language.Norwegian:
+                case "ett"
+                    when language is Language.Swedish:
+                case "euta"
+                    when language is Language.Nepali:
+                case "euti"
+                    when language is Language.Nepali:
+                case "gli"
+                    when language is Language.Italian:
+                case "he"
+                    when language is Language.Hawaiian
+                        || language is Language.Maori:
+                case "het"
+                    when language is Language.Dutch:
+                case "i"
+                    when language is Language.Italian
+                        || language is Language.Khasi:
+                case "il"
+                    when language is Language.Italian:
+                case "in"
+                    when language is Language.Persian:
+                case "ka"
+                    when language is Language.Hawaiian
+                        || language is Language.Khasi:
+                case "ke"
+                    when language is Language.Hawaiian:
+                case "ki"
+                    when language is Language.Khasi:
+                case "kunai"
+                    when language is Language.Nepali:
+                case "l'"
+                    when language is Language.Catalan
+                        || language is Language.French
+                        || language is Language.Italian:
+                case "la"
+                    when language is Language.Catalan
+                        || language is Language.Esperanto
+                        || language is Language.French
+                        || language is Language.Italian
+                        || language is Language.Spanish:
+                case "las"
+                    when language is Language.Spanish:
+                case "le"
+                    when language is Language.French
+                        || language is Language.Interlingua
+                        || language is Language.Italian:
+                case "les"
+                    when language is Language.Catalan
+                        || language is Language.French:
+                case "lo"
+                    when language is Language.Catalan
+                        || language is Language.Italian
+                        || language is Language.Spanish:
+                case "los"
+                    when language is Language.Catalan
+                        || language is Language.Spanish:
+                case "na"
+                    when language is Language.Irish
+                        || language is Language.Gaelic:     // Scottish Gaelic
+                case "nam"
+                    when language is Language.Gaelic:       // Scottish Gaelic
+                case "nan"
+                    when language is Language.Gaelic:       // Scottish Gaelic
+                case "nā"
+                    when language is Language.Hawaiian:
+                case "ngā"
+                    when language is Language.Maori:
+                case "niște"
+                    when language is Language.Romanian:
+                case "ny"
+                    when language is Language.Manx:
+                case "o"
+                    when language is Language.Portuguese
+                        || language is Language.Romanian:
+                case "os"
+                    when language is Language.Portuguese:
+                case "sa"
+                    when language is Language.Catalan:
+                case "sang"
+                    when language is Language.Malay:
+                case "se"
+                    when language is Language.Finnish:
+                case "ses"
+                    when language is Language.Catalan:
+                case "si"
+                    when language is Language.Malay:
+                case "te"
+                    when language is Language.Maori:
+                case "the"
+                    when language is Language.English
+                        || language is Language.Scots:
+                case "u"
+                    when language is Language.Khasi:
+                case "ul"
+                    when language is Language.Breton:
+                case "um"
+                    when language is Language.Portuguese:
+                case "uma"
+                    when language is Language.Portuguese:
+                case "umas"
+                    when language is Language.Portuguese:
+                case "un"
+                    when language is Language.Breton
+                        || language is Language.Catalan
+                        || language is Language.French
+                        || language is Language.Interlingua
+                        || language is Language.Italian
+                        || language is Language.Papiamento
+                        || language is Language.Romanian
+                        || language is Language.Spanish:
+                case "un'"
+                    when language is Language.Italian:
+                case "una"
+                    when language is Language.Catalan
+                        || language is Language.Italian:
+                case "unas"
+                    when language is Language.Spanish:
+                case "une"
+                    when language is Language.French:
+                case "uno"
+                    when language is Language.Italian:
+                case "unos"
+                    when language is Language.Spanish:
+                case "uns"
+                    when language is Language.Catalan
+                        || language is Language.Portuguese:
+                case "unei"
+                    when language is Language.Romanian:
+                case "unes"
+                    when language is Language.Catalan:
+                case "unor"
+                    when language is Language.Romanian:
+                case "unui"
+                    when language is Language.Romanian:
+                case "ur"
+                    when language is Language.Breton:
+                case "y"
+                    when language is Language.Manx
+                        || language is Language.Welsh:
+                case "ye"
+                    when language is Language.Persian:
+                case "yek"
+                    when language is Language.Persian:
+                case "yn"
+                    when language is Language.Manx:
+                case "yr"
+                    when language is Language.Welsh:
+
+                // Non-latin script articles
+                case "ο"
+                    when language is Language.Greek:
+                case "η"
+                    when language is Language.Greek:
+                case "το"
+                    when language is Language.Greek:
+                case "οι"
+                    when language is Language.Greek:
+                case "τα"
+                    when language is Language.Greek:
+                case "ένας"
+                    when language is Language.Greek:
+                case "μια"
+                    when language is Language.Greek:
+                case "ένα"
+                    when language is Language.Greek:
+                case "еден"
+                    when language is Language.Macedonian:
+                case "една"
+                    when language is Language.Macedonian:
+                case "едно"
+                    when language is Language.Macedonian:
+                case "едни"
+                    when language is Language.Macedonian:
+                case "एउटा"
+                    when language is Language.Nepali:
+                case "एउटी"
+                    when language is Language.Nepali:
+                case "एक"
+                    when language is Language.Nepali:
+                case "अनेक"
+                    when language is Language.Nepali:
+                case "कुनै"
+                    when language is Language.Nepali:
+                case "דער"
+                    when language is Language.Yiddish:
+                case "די"
+                    when language is Language.Yiddish:
+                case "דאָס"
+                    when language is Language.Yiddish:
+                case "דעם"
+                    when language is Language.Yiddish:
+                case "אַ"
+                    when language is Language.Yiddish:
+                case "אַן"
+                    when language is Language.Yiddish:
+
+                    break;
+
+                // Otherwise, just return it as-is
+                default:
+                    return title;
+            }
+
+            // Insert the first item if we have a `:` or `-`
+            bool itemInserted = false;
+            var newTitleBuilder = new StringBuilder();
+            for (int i = 1; i < splitTitle.Length; i++)
+            {
+                string segment = splitTitle[i];
+                if (!itemInserted && segment == ":")
+                {
+                    itemInserted = true;
+                    newTitleBuilder.Append($", {firstItem} :");
+                }
+                else if (!itemInserted && segment == "-")
+                {
+                    itemInserted = true;
+                    newTitleBuilder.Append($", {firstItem} -");
+                }
+                else if (!itemInserted && segment.EndsWith(":"))
+                {
+                    itemInserted = true;
+                    newTitleBuilder.Append($" {segment.Substring(0, segment.Length - 1)}, {firstItem}:");
+                }
+                else if (!itemInserted && segment.EndsWith("-"))
+                {
+                    itemInserted = true;
+                    newTitleBuilder.Append($" {segment.Substring(0, segment.Length - 1)}, {firstItem}-");
+                }
+                else
+                {
+                    newTitleBuilder.Append($" {segment}");
+                }
+            }
+
+            // If we didn't insert the item yet, add it to the end
+            string newTitle = newTitleBuilder.ToString().Trim();
+            if (!itemInserted)
+                newTitle = $"{newTitle}, {firstItem}";
+
+            return newTitle;
+        }
+
+        /// <summary>
+        /// Normalize a split set of paths
+        /// </summary>
+        /// <param name="path">Path value to normalize</param>
+        public static string NormalizeOutputPaths(string? path, bool getFullPath)
+        {
+            try
+            {
+                // If we have an invalid path
+                if (string.IsNullOrEmpty(path))
+                    return string.Empty;
+
+                // Remove quotes and angle brackets from path
+                path = path!.Trim('\"');
+                path = path!.Trim('<');
+                path = path!.Trim('>');
+
+                // Remove invalid path characters
+                foreach (char c in Path.GetInvalidPathChars())
+                {
+                    path = path.Replace(c, '_');
+                }
+
+                // Try getting the combined path and returning that directly
+                string fullPath = getFullPath ? Path.GetFullPath(path) : path;
+                var fullDirectory = Path.GetDirectoryName(fullPath)?.Trim();
+                string fullFile = Path.GetFileName(fullPath).Trim();
+
+                // Remove invalid filename characters
+                foreach (char c in Path.GetInvalidFileNameChars())
+                {
+                    fullFile = fullFile.Replace(c, '_');
+                }
+
+                // Rebuild the path, if necessary
+                if (!string.IsNullOrEmpty(fullDirectory))
+                    fullFile = Path.Combine(fullDirectory, fullFile);
+
+                // Remove spaces before and after separators
+                return Regex.Replace(fullFile, @"\s*([\\|/])\s*", @"$1");
+            }
+            catch { }
+
+            return path ?? string.Empty;
+        }
+
+        #endregion
+
+        #region Versioning
+
+        /// <summary>
+        /// Check for a new MPF version
+        /// </summary>
+        /// <returns>
+        /// Bool representing if the values are different.
+        /// String representing the message to display the the user.
+        /// String representing the new release URL.
+        /// </returns>
+        public static void CheckForNewVersion(out bool different, out string message, out string? url)
+        {
+            try
+            {
+                // Get current assembly version
+                var assemblyVersion = Assembly.GetEntryAssembly()?.GetName()?.Version;
+                if (assemblyVersion == null)
+                {
+                    different = false;
+                    message = "Assembly version could not be determined";
+                    url = null;
+                    return;
+                }
+
+                string version = $"{assemblyVersion.Major}.{assemblyVersion.Minor}.{assemblyVersion.Build}";
+
+                // Get the latest tag from GitHub
+                _ = GetRemoteVersionAndUrl(out string? tag, out url);
+                different = version != tag && tag != null;
+
+                message = $"Local version: {version}"
+                    + $"{Environment.NewLine}Remote version: {tag}"
+                    + (different
+                        ? $"{Environment.NewLine}The update URL has been added copied to your clipboard"
+                        : $"{Environment.NewLine}You have the newest version!");
+            }
+            catch (Exception ex)
+            {
+                different = false;
+                message = ex.ToString();
+                url = null;
+            }
+        }
+
+        /// <summary>
+        /// Get the current informational version formatted as a string
+        /// </summary>
+        public static string? GetCurrentVersion()
+        {
+            try
+            {
+                var assembly = Assembly.GetEntryAssembly();
+                if (assembly == null)
+                    return null;
+
+                var assemblyVersion = Attribute.GetCustomAttribute(assembly, typeof(AssemblyInformationalVersionAttribute)) as AssemblyInformationalVersionAttribute;
+                return assemblyVersion?.InformationalVersion;
+            }
+            catch (Exception ex)
+            {
+                return ex.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Get the latest version of MPF from GitHub and the release URL
+        /// </summary>
+        private static bool GetRemoteVersionAndUrl(out string? tag, out string? url)
+        {
+            tag = null; url = null;
+#if NET20 || NET35 || NET40
+            // Not supported in .NET Frameworks 2.0, 3.5, or 4.0
+            return false;
+#else
+            using var hc = new System.Net.Http.HttpClient();
+#if NET452
+            System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12;
+#endif
+
+            // TODO: Figure out a better way than having this hardcoded...
+            string releaseUrl = "https://api.github.com/repos/SabreTools/MPF/releases/latest";
+            var message = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Get, releaseUrl);
+            message.Headers.Add("User-Agent", "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0");
+            var latestReleaseJsonString = hc.SendAsync(message)?.ConfigureAwait(false).GetAwaiter().GetResult()
+                .Content?.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
+            if (latestReleaseJsonString == null)
+                return false;
+
+            var latestReleaseJson = Newtonsoft.Json.Linq.JObject.Parse(latestReleaseJsonString);
+            if (latestReleaseJson == null)
+                return false;
+
+            tag = latestReleaseJson["tag_name"]?.ToString();
+            url = latestReleaseJson["html_url"]?.ToString();
+
+            return true;
+#endif
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/Tools/IRDTool.cs

@@ -0,0 +1,99 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using MPF.Processors;
+
+namespace MPF.Frontend.Tools
+{
+    internal static class IRDTool
+    {
+        /// <summary>
+        /// Create an IRD and write it next to the input ISO path
+        /// </summary>
+        /// <param name="isoPath">Path to the original ISO</param>
+        /// <param name="discKeyString">Required hexadecimal disc key as a string</param>
+        /// <param name="discIDString">Optional hexadecimal disc ID as a string</param>
+        /// <param name="picString">Optional string representation of the PIC information</param>
+        /// <param name="layerbreak">Optional disc layerbreak value</param>
+        /// <param name="crc32">Optional ISO CRC-32 value for the Unique ID field</param>
+        /// <returns>True on success, false on error</returns>
+        public static async Task<bool> WriteIRD(string isoPath,
+            string? discKeyString,
+            string? discIDString,
+            string? picString,
+            long? layerbreak,
+            string? crc32)
+        {
+            try
+            {
+                // Parse string values into required formats
+                byte[]? discKey = ProcessingTool.ParseHexKey(discKeyString);
+                byte[]? discID = ProcessingTool.ParseDiscID(discIDString);
+                byte[]? pic = ProcessingTool.ParsePIC(picString);
+                uint? uid = ProcessingTool.ParseCRC32(crc32);
+
+                return await WriteIRD(isoPath, discKey, discID, pic, layerbreak, uid);
+            }
+            catch (Exception)
+            {
+                // We don't care what the error is
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Create an IRD and write it next to the input ISO path
+        /// </summary>
+        /// <param name="isoPath">Path to the original ISO</param>
+        /// <param name="discKey">Required hexadecimal disc key as a byte array</param>
+        /// <param name="discID">Optional hexadecimal disc ID as a byte array</param>
+        /// <param name="pic">Optional byte array representation of the PIC information</param>
+        /// <param name="layerbreak">Optional disc layerbreak value</param>
+        /// <param name="uid">Optional ISO CRC-32 value for the Unique ID field</param>
+        /// <returns>True on success, false on error</returns>
+        public static async Task<bool> WriteIRD(string isoPath,
+            byte[]? discKey,
+            byte[]? discID,
+            byte[]? pic,
+            long? layerbreak,
+            uint? uid)
+        {
+            try
+            {
+                // Fail on a missing disc key
+                if (discKey == null)
+                    return false;
+
+                // Output IRD file path
+                string irdPath = Path.ChangeExtension(isoPath, ".ird");
+
+                // Ensure layerbreak value is valid
+                layerbreak = ProcessingTool.ParseLayerbreak(layerbreak);
+
+                // Create Redump-style reproducible IRD
+#if NET40
+                LibIRD.ReIRD ird = await Task.Factory.StartNew(() =>
+#else
+                LibIRD.ReIRD ird = await Task.Run(() =>
+#endif
+                    new LibIRD.ReIRD(isoPath, discKey, layerbreak, uid));
+
+                // Set optional fields if valid
+                if (pic != null)
+                    ird.PIC = pic;
+                if (discID != null && ird.DiscID[15] != 0x00)
+                    ird.DiscID = discID;
+
+                // Write IRD to file
+                ird.Write(irdPath);
+
+                return true;
+            }
+            catch (Exception)
+            {
+                // We don't care what the error is
+                return false;
+            }
+        }
+    }
+}

MPF.Frontend/Tools/OptionsLoader.cs

@@ -0,0 +1,395 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using Newtonsoft.Json;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend.Tools
+{
+    public static class OptionsLoader
+    {
+        /// <summary>
+        /// Configuration file name
+        /// </summary>
+        private const string ConfigurationFileName = "config.json";
+
+        /// <summary>
+        /// Full path to the configuration file used by the program
+        /// </summary>
+        private static string ConfigurationPath
+        {
+            get
+            {
+                if (_configPath != null)
+                    return _configPath;
+
+                _configPath = GetConfigurationPath();
+                return _configPath;
+            }
+        }
+        private static string? _configPath = null;
+
+        #region Arguments
+
+        /// <summary>
+        /// Process any standalone arguments for the program
+        /// </summary>
+        /// <returns>True if one of the arguments was processed, false otherwise</returns>
+        public static bool? ProcessStandaloneArguments(string[] args)
+        {
+            // Help options
+            if (args.Length == 0 || args[0] == "-h" || args[0] == "-?" || args[0] == "--help")
+                return null;
+
+            if (args[0] == "--version")
+            {
+                Console.WriteLine(FrontendTool.GetCurrentVersion() ?? "Unknown version");
+                return true;
+            }
+
+            // List options
+            if (args[0] == "-lc" || args[0] == "--listcodes")
+            {
+                Console.WriteLine("Supported Site Codes:");
+                foreach (string siteCode in Extensions.ListSiteCodes())
+                {
+                    Console.WriteLine(siteCode);
+                }
+
+                return true;
+            }
+            else if (args[0] == "-lm" || args[0] == "--listmedia")
+            {
+                Console.WriteLine("Supported Media Types:");
+                foreach (string mediaType in Extensions.ListMediaTypes())
+                {
+                    Console.WriteLine(mediaType);
+                }
+
+                return true;
+            }
+            else if (args[0] == "-lp" || args[0] == "--listprograms")
+            {
+                Console.WriteLine("Supported Programs:");
+                foreach (string program in ListPrograms())
+                {
+                    Console.WriteLine(program);
+                }
+
+                return true;
+            }
+            else if (args[0] == "-ls" || args[0] == "--listsystems")
+            {
+                Console.WriteLine("Supported Systems:");
+                foreach (string system in Extensions.ListSystems())
+                {
+                    Console.WriteLine(system);
+                }
+
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Process common arguments for all functionality
+        /// </summary>
+        /// <returns>True if all arguments pass, false otherwise</returns>
+        public static bool ProcessCommonArguments(string[] args, out RedumpSystem? system, out string? message)
+        {
+            // All other use requires at least 3 arguments
+            if (args.Length < 2)
+            {
+                system = null;
+                message = "Invalid number of arguments";
+                return false;
+            }
+
+            // Check the RedumpSystem
+            system = Extensions.ToRedumpSystem(args[0].Trim('"'));
+            if (system == null)
+            {
+                message = $"{args[0]} is not a recognized system";
+                return false;
+            }
+
+            message = null;
+            return true;
+        }
+
+        /// <summary>
+        /// Get the MediaType enum value for a given string
+        /// </summary>
+        /// <param name="type">String value to convert</param>
+        /// <returns>MediaType represented by the string, if possible</returns>
+        public static MediaType ToMediaType(string? type)
+        {
+            return (type?.ToLowerInvariant()) switch
+            {
+                #region Punched Media
+
+                "aperture"
+                    or "aperturecard"
+                    or "aperture card" => MediaType.ApertureCard,
+                "jacquardloom"
+                    or "jacquardloomcard"
+                    or "jacquard loom card" => MediaType.JacquardLoomCard,
+                "magneticstripe"
+                    or "magneticstripecard"
+                    or "magnetic stripe card" => MediaType.MagneticStripeCard,
+                "opticalphone"
+                    or "opticalphonecard"
+                    or "optical phonecard" => MediaType.OpticalPhonecard,
+                "punchcard"
+                    or "punchedcard"
+                    or "punched card" => MediaType.PunchedCard,
+                "punchtape"
+                    or "punchedtape"
+                    or "punched tape" => MediaType.PunchedTape,
+
+                #endregion
+
+                #region Tape
+
+                "openreel"
+                    or "openreeltape"
+                    or "open reel tape" => MediaType.OpenReel,
+                "datacart"
+                    or "datacartridge"
+                    or "datatapecartridge"
+                    or "data tape cartridge" => MediaType.DataCartridge,
+                "cassette"
+                    or "cassettetape"
+                    or "cassette tape" => MediaType.Cassette,
+
+                #endregion
+
+                #region Disc / Disc
+
+                "bd"
+                    or "bdrom"
+                    or "bd-rom"
+                    or "bluray" => MediaType.BluRay,
+                "cd"
+                    or "cdrom"
+                    or "cd-rom" => MediaType.CDROM,
+                "dvd"
+                    or "dvd5"
+                    or "dvd-5"
+                    or "dvd9"
+                    or "dvd-9"
+                    or "dvdrom"
+                    or "dvd-rom" => MediaType.DVD,
+                "fd"
+                    or "floppy"
+                    or "floppydisk"
+                    or "floppy disk"
+                    or "floppy diskette" => MediaType.FloppyDisk,
+                "floptical" => MediaType.Floptical,
+                "gd"
+                    or "gdrom"
+                    or "gd-rom" => MediaType.GDROM,
+                "hddvd"
+                    or "hd-dvd"
+                    or "hddvdrom"
+                    or "hd-dvd-rom" => MediaType.HDDVD,
+                "hdd"
+                    or "harddisk"
+                    or "hard disk" => MediaType.HardDisk,
+                "bernoullidisk"
+                    or "iomegabernoullidisk"
+                    or "bernoulli disk"
+                    or "iomega bernoulli disk" => MediaType.IomegaBernoulliDisk,
+                "jaz"
+                    or "iomegajaz"
+                    or "iomega jaz" => MediaType.IomegaJaz,
+                "zip"
+                    or "zipdisk"
+                    or "iomegazip"
+                    or "iomega zip" => MediaType.IomegaZip,
+                "ldrom"
+                    or "lvrom"
+                    or "ld-rom"
+                    or "lv-rom"
+                    or "laserdisc"
+                    or "laservision"
+                    or "ld-rom / lv-rom" => MediaType.LaserDisc,
+                "64dd"
+                    or "n64dd"
+                    or "64dddisk"
+                    or "n64dddisk"
+                    or "64dd disk"
+                    or "n64dd disk" => MediaType.Nintendo64DD,
+                "fds"
+                    or "famicom"
+                    or "nfds"
+                    or "nintendofamicom"
+                    or "famicomdisksystem"
+                    or "famicom disk system"
+                    or "famicom disk system disk" => MediaType.NintendoFamicomDiskSystem,
+                "gc"
+                    or "gamecube"
+                    or "nintendogamecube"
+                    or "nintendo gamecube"
+                    or "gamecube disc"
+                    or "gamecube game disc" => MediaType.NintendoGameCubeGameDisc,
+                "wii"
+                    or "nintendowii"
+                    or "nintendo wii"
+                    or "nintendo wii disc"
+                    or "wii optical disc" => MediaType.NintendoWiiOpticalDisc,
+                "wiiu"
+                    or "nintendowiiu"
+                    or "nintendo wiiu"
+                    or "nintendo wiiu disc"
+                    or "wiiu optical disc"
+                    or "wii u optical disc" => MediaType.NintendoWiiUOpticalDisc,
+                "umd" => MediaType.UMD,
+
+                #endregion
+
+                // Unsorted Formats
+                "cartridge" => MediaType.Cartridge,
+                "ced"
+                    or "rcaced"
+                    or "rca ced"
+                    or "videodisc"
+                    or "rca videodisc" => MediaType.CED,
+
+                _ => MediaType.NONE,
+            };
+        }
+
+        /// <summary>
+        /// List all programs with their short usable names
+        /// </summary>
+        private static List<string> ListPrograms()
+        {
+            var programs = new List<string>();
+
+            foreach (var val in Enum.GetValues(typeof(InternalProgram)))
+            {
+                if (((InternalProgram)val!) == InternalProgram.NONE)
+                    continue;
+
+                programs.Add($"{((InternalProgram?)val).ShortName()} - {((InternalProgram?)val).LongName()}");
+            }
+
+            return programs;
+        }
+
+        #endregion
+
+        #region Configuration
+
+        /// <summary>
+        /// Load the current set of options from the application configuration
+        /// </summary>
+        public static Options LoadFromConfig()
+        {
+            // If no options path can be found
+            if (string.IsNullOrEmpty(ConfigurationPath))
+                return new Options();
+
+            // Ensure the file exists
+            if (!File.Exists(ConfigurationPath) || new FileInfo(ConfigurationPath).Length == 0)
+            {
+                File.Create(ConfigurationPath).Dispose();
+                return new Options();
+            }
+
+            var serializer = JsonSerializer.Create();
+            var stream = File.Open(ConfigurationPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
+            var reader = new StreamReader(stream);
+            var settings = serializer.Deserialize(reader, typeof(Dictionary<string, string?>)) as Dictionary<string, string?>;
+            reader.Dispose();
+            return new Options(settings);
+        }
+
+        /// <summary>
+        /// Save the current set of options to the application configuration
+        /// </summary>
+        public static void SaveToConfig(Options options)
+        {
+            // If no options path can be found
+            if (string.IsNullOrEmpty(ConfigurationPath))
+                return;
+
+            // Ensure default values are included
+            PropertyInfo[] properties = typeof(Options).GetProperties();
+            foreach (var property in properties)
+            {
+                // Skip dictionary properties
+                if (property.Name == "Item")
+                    continue;
+
+                // Skip non-option properties
+                if (property.Name == "Settings" || property.Name == "HasRedumpLogin")
+                    continue;
+
+                var val = property.GetValue(options, null);
+                property.SetValue(options, val, null);
+            }
+
+            // Handle a very strange edge case
+            if (!File.Exists(ConfigurationPath))
+                File.Create(ConfigurationPath).Dispose();
+
+            var serializer = JsonSerializer.Create();
+            var sw = new StreamWriter(ConfigurationPath) { AutoFlush = true };
+            var writer = new JsonTextWriter(sw) { Formatting = Formatting.Indented };
+            serializer.Serialize(writer, options.Settings, typeof(Dictionary<string, string>));
+        }
+
+        /// <summary>
+        /// Attempt to determine the configuration path
+        /// </summary>
+        private static string GetConfigurationPath()
+        {
+            // User home directory
+#if NET20 || NET35
+            string homeDir = Environment.ExpandEnvironmentVariables("%HOMEDRIVE%%HOMEPATH%");
+            homeDir = Path.Combine(Path.Combine(homeDir, ".config"), "mpf");
+#else
+            string homeDir = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+            homeDir = Path.Combine(homeDir, ".config", "mpf");
+#endif
+            if (File.Exists(Path.Combine(homeDir, ConfigurationFileName)))
+                return Path.Combine(homeDir, ConfigurationFileName);
+
+            // Local folder
+#if NET20 || NET35 || NET40 || NET452
+            string runtimeDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+#else
+            string runtimeDir = AppContext.BaseDirectory;
+#endif
+            if (File.Exists(Path.Combine(runtimeDir, ConfigurationFileName)))
+                return Path.Combine(runtimeDir, ConfigurationFileName);
+
+            // Attempt to use local folder
+            try
+            {
+                Directory.CreateDirectory(runtimeDir);
+                File.Create(Path.Combine(runtimeDir, ConfigurationFileName)).Dispose();
+                return Path.Combine(runtimeDir, ConfigurationFileName);
+            }
+            catch { }
+
+            // Attempt to use home directory
+            try
+            {
+                Directory.CreateDirectory(homeDir);
+                File.Create(Path.Combine(homeDir, ConfigurationFileName)).Dispose();
+                return Path.Combine(homeDir, ConfigurationFileName);
+            }
+            catch { }
+
+            // This should not happen
+            return string.Empty;
+        }
+
+        #endregion
+    }
+}

MPF.Frontend/Tools/PhysicalTool.cs

@@ -0,0 +1,818 @@
+using System;
+using System.IO;
+using System.Text;
+using System.Text.RegularExpressions;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using SabreTools.IO;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend.Tools
+{
+    public static class PhysicalTool
+    {
+        #region Generic
+
+        /// <summary>
+        /// Get the last modified date for a file from a physical disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <param name="filePath">Relative file path</param>
+        /// <returns>Output last modified date in "yyyy-mm-dd" format if possible, null on error</returns>
+        public static string? GetFileDate(Drive? drive, string? filePath, bool fixTwoDigitYear = false)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // If the executable name is invalid, we can't do this part
+            if (string.IsNullOrEmpty(filePath))
+                return null;
+
+            // Now that we have the EXE name, try to get the fileinfo for it
+            string exePath = Path.Combine(drive.Name, filePath);
+            if (!File.Exists(exePath))
+                return null;
+
+            try
+            {
+                // Get the last modified time
+                var fi = new FileInfo(exePath);
+                var lastModified = fi.LastWriteTimeUtc;
+                int year = lastModified.Year;
+                int month = lastModified.Month;
+                int day = lastModified.Day;
+
+                // Fix the Y2K timestamp issue, if required
+                if (fixTwoDigitYear)
+                    year = year >= 1900 && year < 1920 ? 2000 + year % 100 : year;
+
+                // Format and return the string
+                var dt = new DateTime(year, month, day);
+                return dt.ToString("yyyy-MM-dd");
+            }
+            catch
+            {
+                // We don't care what the error is
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the first numBytes bytes from a disc drive
+        /// </summary>
+        /// <param name="drive">Drive to get sector from</param>
+        /// <param name="numBytes">Number of bytes to read from drive, maximum of one sector (2048 bytes)</param>
+        /// <returns>Byte array of first sector of data, null on error</returns>
+        public static byte[]? GetFirstBytes(Drive? drive, int numBytes)
+        {
+            if (drive == null || drive.Letter == null || drive.Letter == '\0')
+                return null;
+
+            // Must read between 1 and 2048 bytes
+            if (numBytes < 1)
+                return null;
+            else if (numBytes > 2048)
+                numBytes = 2048;
+
+            string drivePath = $"\\\\.\\{drive.Letter}:";
+            var firstSector = new byte[numBytes];
+            try
+            {
+                // Open the drive as a raw device
+                using var driveStream = new FileStream(drivePath, FileMode.Open, FileAccess.Read);
+
+                // Read the first sector
+                int bytesRead = driveStream.Read(firstSector, 0, numBytes);
+                if (bytesRead < numBytes)
+                    return null;
+            }
+            catch
+            {
+                // We don't care what the error is
+                return null;
+            }
+
+            return firstSector;
+        }
+
+        #endregion
+
+        #region BD-Video
+
+        /// <summary>
+        /// Get if the Bus Encryption Enabled (BEE) flag is set in a path
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Bus encryption enabled status if possible, false otherwise</returns>
+        public static bool GetBusEncryptionEnabled(Drive? drive)
+        {
+            // If there's no drive path, we can't get BEE flag
+            if (string.IsNullOrEmpty(drive?.Name))
+                return false;
+
+            // If the folder no longer exists, we can't get exe name
+            if (!Directory.Exists(drive!.Name))
+                return false;
+
+            // Get the two possible file paths
+#if NET20 || NET35
+            string content000 = Path.Combine(Path.Combine(drive.Name, "AACS"), "Content000.cer");
+            string content001 = Path.Combine(Path.Combine(drive.Name, "AACS"), "Content001.cer");
+#else
+            string content000 = Path.Combine(drive.Name, "AACS", "Content000.cer");
+            string content001 = Path.Combine(drive.Name, "AACS", "Content001.cer");
+#endif
+
+            try
+            {
+                // Check the required files
+                if (File.Exists(content000) && new FileInfo(content000).Length > 1)
+                {
+                    using var fs = File.OpenRead(content000);
+                    _ = fs.ReadByte(); // Skip the first byte
+                    return fs.ReadByte() > 127;
+                }
+                else if (File.Exists(content001) && new FileInfo(content001).Length > 1)
+                {
+                    using var fs = File.OpenRead(content001);
+                    _ = fs.ReadByte(); // Skip the first byte
+                    return fs.ReadByte() > 127;
+                }
+
+                // False if neither file fits the criteria
+                return false;
+            }
+            catch
+            {
+                // We don't care what the error is
+                return false;
+            }
+        }
+
+        #endregion
+
+        #region PlayStation
+
+        /// <summary>
+        /// Get the EXE name from a PlayStation disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Executable name on success, null otherwise</returns>
+        public static string? GetPlayStationExecutableName(Drive? drive)
+        {
+            // If there's no drive path, we can't get exe name
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't get exe name
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Get the two paths that we will need to check
+            string psxExePath = Path.Combine(drive.Name, "PSX.EXE");
+            string systemCnfPath = Path.Combine(drive.Name, "SYSTEM.CNF");
+
+            try
+            {
+                // Read the CNF file as an INI file
+                var systemCnf = new IniFile(systemCnfPath);
+                string? bootValue = string.Empty;
+
+                // PlayStation uses "BOOT" as the key
+                if (systemCnf.ContainsKey("BOOT"))
+                    bootValue = systemCnf["BOOT"];
+
+                // PlayStation 2 uses "BOOT2" as the key
+                if (systemCnf.ContainsKey("BOOT2"))
+                    bootValue = systemCnf["BOOT2"];
+
+                // If we had any boot value, parse it and get the executable name
+                if (!string.IsNullOrEmpty(bootValue))
+                {
+                    var match = Regex.Match(bootValue, @"cdrom.?:\\?(.*)", RegexOptions.Compiled);
+                    if (match.Groups.Count > 1)
+                    {
+                        // Some games may have the EXE in a subfolder
+                        string? serial = match.Groups[1].Value;
+                        return Path.GetFileName(serial);
+                    }
+                }
+            }
+            catch
+            {
+                // We don't care what the error is, assume SYSTEM.CNF doesn't exist
+            }
+
+            // If the SYSTEM.CNF value can't be found, try PSX.EXE
+            if (File.Exists(psxExePath))
+                return "PSX.EXE";
+
+            // If neither can be found, we return null
+            return null;
+        }
+
+        /// <summary>
+        /// Get the serial from a PlayStation disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Serial on success, null otherwise</returns>
+        public static string? GetPlayStationSerial(Drive? drive)
+        {
+            // Try to get the executable name
+            string? exeName = GetPlayStationExecutableName(drive);
+            if (string.IsNullOrEmpty(exeName))
+                return null;
+
+            // Handle generic PSX.EXE
+            if (exeName == "PSX.EXE")
+                return null;
+
+            // EXE name may have a trailing `;` after
+            // EXE name should always be in all caps
+            exeName = exeName!
+                .Split(';')[0]
+                .ToUpperInvariant();
+
+            // Serial is most of the EXE name normalized
+            return exeName
+                .Replace('_', '-')
+                .Replace(".", string.Empty);
+        }
+
+        /// <summary>
+        /// Get the version from a PlayStation 2 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Game version if possible, null on error</returns>
+        public static string? GetPlayStation2Version(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Get the SYSTEM.CNF path to check
+            string systemCnfPath = Path.Combine(drive.Name, "SYSTEM.CNF");
+
+            try
+            {
+                // Try to parse the SYSTEM.CNF file
+                var systemCnf = new IniFile(systemCnfPath);
+                if (systemCnf.ContainsKey("VER"))
+                    return systemCnf["VER"];
+
+                // If "VER" can't be found, we can't do much
+                return null;
+            }
+            catch
+            {
+                // We don't care what the error is
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the internal serial from a PlayStation 3 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Internal disc serial if possible, null on error</returns>
+        public static string? GetPlayStation3Serial(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Attempt to use PS3_DISC.SFB
+            string sfbPath = Path.Combine(drive.Name, "PS3_DISC.SFB");
+            if (File.Exists(sfbPath))
+            {
+                try
+                {
+                    using var br = new BinaryReader(File.OpenRead(sfbPath));
+                    br.BaseStream.Seek(0x220, SeekOrigin.Begin);
+                    return new string(br.ReadChars(0x10)).TrimEnd('\0');
+                }
+                catch
+                {
+                    // We don't care what the error was
+                    return null;
+                }
+            }
+
+            // Attempt to use PARAM.SFO
+#if NET20 || NET35
+            string sfoPath = Path.Combine(Path.Combine(drive.Name, "PS3_GAME"), "PARAM.SFO");
+#else
+            string sfoPath = Path.Combine(drive.Name, "PS3_GAME", "PARAM.SFO");
+#endif
+            if (File.Exists(sfoPath))
+            {
+                try
+                {
+                    using var br = new BinaryReader(File.OpenRead(sfoPath));
+                    br.BaseStream.Seek(-0x18, SeekOrigin.End);
+                    return new string(br.ReadChars(9)).TrimEnd('\0').Insert(4, "-");
+                }
+                catch
+                {
+                    // We don't care what the error was
+                    return null;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get the version from a PlayStation 3 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Game version if possible, null on error</returns>
+        public static string? GetPlayStation3Version(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Attempt to use PS3_DISC.SFB
+            string sfbPath = Path.Combine(drive.Name, "PS3_DISC.SFB");
+            if (File.Exists(sfbPath))
+            {
+                try
+                {
+                    using var br = new BinaryReader(File.OpenRead(sfbPath));
+                    br.BaseStream.Seek(0x230, SeekOrigin.Begin);
+                    var discVersion = new string(br.ReadChars(0x10)).TrimEnd('\0');
+                    if (!string.IsNullOrEmpty(discVersion))
+                        return discVersion;
+                }
+                catch
+                {
+                    // We don't care what the error was
+                    return null;
+                }
+            }
+
+            // Attempt to use PARAM.SFO
+#if NET20 || NET35
+            string sfoPath = Path.Combine(Path.Combine(drive.Name, "PS3_GAME"), "PARAM.SFO");
+#else
+            string sfoPath = Path.Combine(drive.Name, "PS3_GAME", "PARAM.SFO");
+#endif
+            if (File.Exists(sfoPath))
+            {
+                try
+                {
+                    using var br = new BinaryReader(File.OpenRead(sfoPath));
+                    br.BaseStream.Seek(-0x08, SeekOrigin.End);
+                    return new string(br.ReadChars(5)).TrimEnd('\0');
+                }
+                catch
+                {
+                    // We don't care what the error was
+                    return null;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get the firmware version from a PlayStation 3 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Firmware version if possible, null on error</returns>
+        public static string? GetPlayStation3FirmwareVersion(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Attempt to read from /PS3_UPDATE/PS3UPDAT.PUP
+#if NET20 || NET35
+            string pupPath = Path.Combine(Path.Combine(drive.Name, "PS3_UPDATE"), "PS3UPDAT.PUP");
+#else
+            string pupPath = Path.Combine(drive.Name, "PS3_UPDATE", "PS3UPDAT.PUP");
+#endif
+            if (!File.Exists(pupPath))
+                return null;
+
+            try
+            {
+                using var br = new BinaryReader(File.OpenRead(pupPath));
+                br.BaseStream.Seek(0x3E, SeekOrigin.Begin);
+                byte[] buf = new byte[2];
+                br.Read(buf, 0, 2);
+                Array.Reverse(buf);
+                short location = BitConverter.ToInt16(buf, 0);
+                br.BaseStream.Seek(location, SeekOrigin.Begin);
+                return new string(br.ReadChars(4));
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the internal serial from a PlayStation 4 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Internal disc serial if possible, null on error</returns>
+        public static string? GetPlayStation4Serial(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // If we can't find param.sfo, we don't have a PlayStation 4 disc
+#if NET20 || NET35
+            string paramSfoPath = Path.Combine(Path.Combine(drive.Name, "bd"), "param.sfo");
+#else
+            string paramSfoPath = Path.Combine(drive.Name, "bd", "param.sfo");
+#endif
+            if (!File.Exists(paramSfoPath))
+                return null;
+
+            // Let's try reading param.sfo to find the serial at the end of the file
+            try
+            {
+                using var br = new BinaryReader(File.OpenRead(paramSfoPath));
+                br.BaseStream.Seek(-0x14, SeekOrigin.End);
+                return new string(br.ReadChars(9)).Insert(4, "-");
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the version from a PlayStation 4 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Game version if possible, null on error</returns>
+        public static string? GetPlayStation4Version(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // If we can't find param.sfo, we don't have a PlayStation 4 disc
+#if NET20 || NET35
+            string paramSfoPath = Path.Combine(Path.Combine(drive.Name, "bd"), "param.sfo");
+#else
+            string paramSfoPath = Path.Combine(drive.Name, "bd", "param.sfo");
+#endif
+            if (!File.Exists(paramSfoPath))
+                return null;
+
+            // Let's try reading param.sfo to find the version at the end of the file
+            try
+            {
+                using var br = new BinaryReader(File.OpenRead(paramSfoPath));
+                br.BaseStream.Seek(-0x08, SeekOrigin.End);
+                return new string(br.ReadChars(5));
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the app.pkg info from a PlayStation 4 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>PKG info if possible, null on error</returns>
+        public static string? GetPlayStation4PkgInfo(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Try parse the app.pkg (multiple if they exist)
+            try
+            {
+                string? pkgInfo = "";
+
+                string[] appDirs = Directory.GetDirectories(Path.Combine(drive.Name, "app"), "?????????", SearchOption.TopDirectoryOnly);
+
+                foreach (string dir in appDirs)
+                {
+                    string appPkgPath = Path.Combine(dir, "app.pkg");
+                    if (!File.Exists(appPkgPath))
+                        continue;
+
+                    long appPkgSize = new FileInfo(appPkgPath).Length;
+                    if (appPkgSize < 4096)
+                        continue;
+
+                    // Read the app.pkg header
+                    using var fileStream = new FileStream(appPkgPath, FileMode.Open, FileAccess.Read);
+                    var appPkgHeaderDeserializer = new SabreTools.Serialization.Readers.AppPkgHeader();
+                    var appPkgHeader = appPkgHeaderDeserializer.Deserialize(fileStream);
+
+                    if (appPkgHeader != null)
+                        pkgInfo += $"{appPkgHeader.ContentID}{Environment.NewLine}";
+                }
+
+                if (pkgInfo == "")
+                    return null;
+                else
+                    return pkgInfo;
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the internal serial from a PlayStation 5 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Internal disc serial if possible, null on error</returns>
+        public static string? GetPlayStation5Serial(Drive? drive)
+        {
+            // Attempt to get the param.json file
+            var json = GetPlayStation5ParamsJsonFromDrive(drive);
+            if (json == null)
+                return null;
+
+            try
+            {
+                return json["disc"]?[0]?["masterDataId"]?.Value<string>()?.Insert(4, "-");
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        // <summary>
+        /// Get the version from a PlayStation 5 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Game version if possible, null on error</returns>
+        public static string? GetPlayStation5Version(Drive? drive)
+        {
+            // Attempt to get the param.json file
+            var json = GetPlayStation5ParamsJsonFromDrive(drive);
+            if (json == null)
+                return null;
+
+            try
+            {
+                return json["masterVersion"]?.Value<string>();
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the params.json file from a drive path, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>JObject representing the JSON on success, null on error</returns>
+        private static JObject? GetPlayStation5ParamsJsonFromDrive(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // If we can't find param.json, we don't have a PlayStation 5 disc
+#if NET20 || NET35
+            string paramJsonPath = Path.Combine(Path.Combine(drive.Name, "bd"), "param.json");
+#else
+            string paramJsonPath = Path.Combine(drive.Name, "bd", "param.json");
+#endif
+            return GetPlayStation5ParamsJsonFromFile(paramJsonPath);
+        }
+
+        /// <summary>
+        /// Get the params.json file from a filename, if possible
+        /// </summary>
+        /// <param name="filename">Filename to check</param>
+        /// <returns>JObject representing the JSON on success, null on error</returns>
+        private static JObject? GetPlayStation5ParamsJsonFromFile(string? filename)
+        {
+            // If the file doesn't exist
+            if (string.IsNullOrEmpty(filename))
+                return null;
+            if (!File.Exists(filename))
+                return null;
+
+            // Let's try reading param.json to find the version in the unencrypted JSON
+            try
+            {
+                using var br = new BinaryReader(File.OpenRead(filename));
+                br.BaseStream.Seek(0x800, SeekOrigin.Begin);
+                byte[] jsonBytes = br.ReadBytes((int)(br.BaseStream.Length - 0x800));
+                return JsonConvert.DeserializeObject(Encoding.ASCII.GetString(jsonBytes)) as JObject;
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Get the app.pkg info from a PlayStation 5 disc, if possible
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>PKG info if possible, null on error</returns>
+        public static string? GetPlayStation5PkgInfo(Drive? drive)
+        {
+            // If there's no drive path, we can't do this part
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't do this part
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Try parse the app_sc.pkg (multiple if they exist)
+            try
+            {
+                string? pkgInfo = "";
+
+                string[] appDirs = Directory.GetDirectories(Path.Combine(drive.Name, "app"), "?????????", SearchOption.TopDirectoryOnly);
+
+                foreach (string dir in appDirs)
+                {
+                    string appPkgPath = Path.Combine(dir, "app_sc.pkg");
+                    if (!File.Exists(appPkgPath))
+                        continue;
+
+                    long appPkgSize = new FileInfo(appPkgPath).Length;
+                    if (appPkgSize < 4096)
+                        continue;
+
+                    // Read the app_sc.pkg header
+                    using var fileStream = new FileStream(appPkgPath, FileMode.Open, FileAccess.Read);
+                    var appPkgHeaderDeserializer = new SabreTools.Serialization.Readers.AppPkgHeader();
+                    var appPkgHeader = appPkgHeaderDeserializer.Deserialize(fileStream);
+
+                    if (appPkgHeader != null)
+                        pkgInfo += $"{appPkgHeader.ContentID}{Environment.NewLine}";
+                }
+
+                if (pkgInfo == "")
+                    return null;
+                else
+                    return pkgInfo;
+            }
+            catch
+            {
+                // We don't care what the error was
+                return null;
+            }
+        }
+
+        #endregion
+
+        #region Xbox
+
+        /// <summary>
+        /// Get all filenames for Xbox One and Xbox Series X
+        /// </summary>
+        /// <param name="drive">Drive to extract information from</param>
+        /// <returns>Filenames if possible, null on error</returns>
+        public static string? GetXboxFilenames(Drive? drive)
+        {
+            // If there's no drive path, we can't get BEE flag
+            if (string.IsNullOrEmpty(drive?.Name))
+                return null;
+
+            // If the folder no longer exists, we can't get exe name
+            if (!Directory.Exists(drive!.Name))
+                return null;
+
+            // Get the MSXC directory path
+            string msxc = Path.Combine(drive.Name, "MSXC");
+            if (!Directory.Exists(msxc))
+                return null;
+
+            try
+            {
+                var files = Directory.GetFiles(msxc, "*", SearchOption.TopDirectoryOnly);
+                var filenames = Array.ConvertAll(files, Path.GetFileName);
+                return string.Join("\n", filenames);
+            }
+            catch
+            {
+                // We don't care what the error is
+                return null;
+            }
+        }
+
+        #endregion
+
+        #region Sega
+
+        /// <summary>
+        /// Detect the Sega system based on the CD ROM header
+        /// </summary>
+        /// <param name="drive">Drive to detect system from</param>
+        /// <returns>Detected RedumpSystem if detected, null otherwise</returns>
+        public static RedumpSystem? DetectSegaSystem(Drive? drive)
+        {
+            if (drive == null)
+                return null;
+
+            byte[]? firstSector = GetFirstBytes(drive, 0x10);
+            if (firstSector == null || firstSector.Length < 0x10)
+                return null;
+
+            string systemType = Encoding.ASCII.GetString(firstSector, 0x00, 0x10);
+
+            if (systemType.Equals("SEGA SEGASATURN ", StringComparison.Ordinal))
+                return RedumpSystem.SegaSaturn;
+            else if (systemType.Equals("SEGA SEGAKATANA ", StringComparison.Ordinal))
+                return RedumpSystem.SegaDreamcast;
+            else if (systemType.Equals("SEGADISCSYSTEM  ", StringComparison.Ordinal))
+                return RedumpSystem.SegaMegaCDSegaCD;
+            else if (systemType.Equals("SEGA MEGA DRIVE ", StringComparison.Ordinal))
+                return RedumpSystem.SegaMegaCDSegaCD;
+            else if (systemType.Equals("SEGA GENESIS    ", StringComparison.Ordinal))
+                return RedumpSystem.SegaMegaCDSegaCD;
+
+            return null;
+        }
+
+        #endregion
+
+        #region Other
+
+        /// <summary>
+        /// Detect a 3DO disc based on the CD ROM header
+        /// </summary>
+        /// <param name="drive">Drive to detect 3DO disc from</param>
+        /// <returns>RedumpSystem.Panasonic3DOInteractiveMultiplayer if detected, null otherwise</returns>
+        public static RedumpSystem? Detect3DOSystem(Drive? drive)
+        {
+            if (drive == null)
+                return null;
+
+            byte[]? firstSector = GetFirstBytes(drive, 0xC0);
+            if (firstSector == null || firstSector.Length < 0xC0)
+                return null;
+
+            string systemType = Encoding.ASCII.GetString(firstSector, 0xB0, 0x10);
+
+            if (systemType.Equals("iamaduckiamaduck", StringComparison.Ordinal))
+                return RedumpSystem.Panasonic3DOInteractiveMultiplayer;
+
+            return null;
+        }
+
+        #endregion
+
+    }
+}

MPF.Frontend/Tools/ProtectionTool.cs

@@ -0,0 +1,561 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+#if NET35_OR_GREATER || NETCOREAPP
+using System.Linq;
+#endif
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using BinaryObjectScanner;
+using SabreTools.IO.Extensions;
+
+namespace MPF.Frontend.Tools
+{
+    public static class ProtectionTool
+    {
+        /// <summary>
+        /// Set of protection prefixes to filter on
+        /// </summary>
+        /// <remarks>Based on Redump requirements</remarks>
+        private static readonly string[] FilterPrefixes = [
+            #region Game Engine
+
+            "RenderWare",
+
+            #endregion
+
+            #region Packers
+
+            ".NET Reactor",
+            "7-Zip SFX",
+            "ASPack",
+            "AutoPlay Media Studio",
+            "Caphyon Advanced Installer",
+            "CExe",
+            "dotFuscator",
+            "Embedded",
+            "EXE Stealth",
+            "Gentee Installer",
+            "HyperTech CrackProof",
+            "Inno Setup",
+            "InstallAnywhere",
+            "Installer VISE",
+            "Intel Installation Framework",
+            "Microsoft CAB SFX",
+            "NeoLite",
+            "NSIS",
+            "PE Compact",
+            "PEtite",
+            "Setup Factory",
+            "Shrinker",
+            "UPX",
+            "WinRAR SFX",
+            "WinZip SFX",
+            "Wise Installation",
+
+            #endregion
+
+            #region Protections
+
+            "CD-Key / Serial",
+            "EA CdKey",
+            "Executable-Based CD Check",
+            "Executable-Based Online Registration",
+
+            #endregion
+        ];
+
+        /// <summary>
+        /// Run protection scan on a given path
+        /// </summary>
+        /// <param name="path">Path to scan for protection</param>
+        /// <param name="options">Options object that determines what to scan</param>
+        /// <param name="progress">Optional progress callback</param>
+        /// <returns>Set of all detected copy protections with an optional error string</returns>
+        public static async Task<Dictionary<string, List<string>>> RunProtectionScanOnPath(string path,
+            Options options,
+            IProgress<ProtectionProgress>? progress = null)
+        {
+#if NET40
+            var found = await Task.Factory.StartNew(() =>
+#else
+            var found = await Task.Run(() =>
+#endif
+            {
+                var scanner = new Scanner(
+                    options.ScanArchivesForProtection,
+                    scanContents: true, // Hardcoded value to avoid issues
+                    scanPaths: true, // Hardcoded value to avoid issues
+                    scanSubdirectories: true, // Hardcoded value to avoid issues
+                    options.IncludeDebugProtectionInformation,
+                    progress);
+
+                return scanner.GetProtections(path);
+            });
+
+            // If nothing was returned, return
+            if (found == null || found.Count == 0)
+                return [];
+
+            // Return the filtered set of protections
+            return found;
+        }
+
+        /// <summary>
+        /// Format found protections to a deduplicated, ordered string
+        /// </summary>
+        /// <param name="protections">Dictionary of file to list of protection mappings</param>
+        /// <returns>Detected protections, if any</returns>
+        public static string? FormatProtections(Dictionary<string, List<string>>? protections)
+        {
+            // If the filtered list is empty in some way, return
+            if (protections == null)
+                return "(CHECK WITH PROTECTIONID)";
+            else if (protections.Count == 0)
+                return "None found [OMIT FROM SUBMISSION]";
+
+            // Sanitize context-sensitive protections
+            protections = SanitizeContextSensitiveProtections(protections);
+
+            // Get a list of distinct found protections
+#if NET20
+            var protectionValues = new List<string>();
+            foreach (var value in protections.Values)
+            {
+                if (value.Count == 0)
+                    continue;
+                
+                foreach (var prot in value)
+                {
+                    if (!protectionValues.Contains(prot))
+                        protectionValues.Add(prot);
+                }
+            }
+#else
+            var protectionValues = protections
+                .SelectMany(kvp => kvp.Value)
+                .Distinct()
+                .ToList();
+#endif
+            
+            // Sanitize and join protections for writing
+            string protectionString = SanitizeFoundProtections(protectionValues);
+            if (string.IsNullOrEmpty(protectionString))
+                return "None found [OMIT FROM SUBMISSION]";
+
+            return protectionString;
+        }
+
+        /// <summary>
+        /// Get the existence of an anti-modchip string from a PlayStation disc, if possible
+        /// </summary>
+        /// <param name="path">Path to scan for anti-modchip strings</param>
+        /// <returns>Anti-modchip existence if possible, false on error</returns>
+        public static async Task<bool> GetPlayStationAntiModchipDetected(string? path)
+        {
+            // If there is no valid path
+            if (string.IsNullOrEmpty(path))
+                return false;
+
+#if NET40
+            return await Task.Factory.StartNew(() =>
+#else
+            return await Task.Run(() =>
+#endif
+            {
+                try
+                {
+                    var antiModchip = new BinaryObjectScanner.Protection.PSXAntiModchip();
+                    foreach (string file in IOExtensions.SafeGetFiles(path!, "*", SearchOption.AllDirectories))
+                    {
+                        try
+                        {
+                            byte[] fileContent = File.ReadAllBytes(file);
+                            var protection = antiModchip.CheckContents(file, fileContent, false);
+                            if (!string.IsNullOrEmpty(protection))
+                                return true;
+                        }
+                        catch { }
+                    }
+                }
+                catch { }
+
+                return false;
+            });
+        }
+
+        /// <summary>
+        /// Sanitize unnecessary protections where context matters
+        /// </summary>
+        /// <param name="protections">Dictionary of file to list of protection mappings</param>
+        /// <returns>Dictionary with all necessary items filtered out</returns>
+        public static Dictionary<string, List<string>> SanitizeContextSensitiveProtections(Dictionary<string, List<string>> protections)
+        {
+            // Setup the output dictionary
+            Dictionary<string, List<string>> filtered = [];
+
+            // Setup a list for keys that need additional processing
+            List<string> foundKeys = [];
+
+            // Loop through the keys and add relevant ones
+            string[] paths = [.. protections.Keys];
+            foreach (var path in paths)
+            {
+                if (!protections.TryGetValue(path, out var values) || values == null || values.Count == 0)
+                    continue;
+
+                // Always copy the values if they're valid
+                filtered[path] = values;
+
+                if (values.Exists(s => s.StartsWith("SecuROM Release Control -")))
+                    foundKeys.Add(path);
+            }
+
+            // If there are no keys found
+            if (foundKeys.Count == 0)
+                return filtered;
+
+            // Process the keys as necessary
+            foreach (var key in foundKeys)
+            {
+                // Get all matching paths
+                var matchingPaths = Array.FindAll(paths, s => s != key && s.StartsWith(key));
+                if (matchingPaths.Length == 0)
+                    continue;
+
+                // Loop through the matching paths
+                foreach (var path in matchingPaths)
+                {
+                    if (!filtered.TryGetValue(path, out var values) || values == null || values.Count == 0)
+                        continue;
+
+                    if (values.Exists(s => !s.Contains("GitHub") &&
+                        (s.Contains("SecuROM 7")
+                            || s.Contains("SecuROM 8")
+                            || s.Contains("SecuROM Content Activation")
+                            || s.Contains("SecuROM Data File Activation")
+                            || s.Contains("Unlock"))))
+                    {
+                        filtered.Remove(path);
+                    }
+                }
+            }
+
+            return filtered;
+        }
+
+        /// <summary>
+        /// Sanitize unnecessary protection duplication from output
+        /// </summary>
+        /// <param name="foundProtections">Enumerable of found protections</param>
+        /// <remarks>
+        /// This filtering only impacts the information that goes into the single-line
+        /// protection field in the output submission info. The filtering performed by
+        /// this method applies to the needs of Redump and not necessarily any other
+        /// application. The full protection list should be used as a reference in all
+        /// other cases.
+        /// </remarks>
+        public static string SanitizeFoundProtections(List<string> foundProtections)
+        {
+            // EXCEPTIONS
+            if (foundProtections.Exists(p => p.StartsWith("[Exception opening file")))
+            {
+                foundProtections = foundProtections.FindAll(p => !p.StartsWith("[Exception opening file") && !p.StartsWith("[Access issue when opening file"));
+                foundProtections.Add("Exception occurred while scanning [RESCAN NEEDED]");
+            }
+            if (foundProtections.Exists(p => p.StartsWith("[Access issue when opening file")))
+            {
+                foundProtections = foundProtections.FindAll(p => !p.StartsWith("[Exception opening file") && !p.StartsWith("[Access issue when opening file"));
+                foundProtections.Add("Exception occurred while scanning [RESCAN NEEDED]");
+            }
+
+            // Filtered prefixes
+            foreach (string prefix in FilterPrefixes)
+            {
+                foundProtections = foundProtections.FindAll(p => !p.StartsWith(prefix));
+            }
+
+            // ActiveMARK
+            if (foundProtections.Exists(p => p == "ActiveMARK 5")
+                && foundProtections.Exists(p => p == "ActiveMARK"))
+            {
+                foundProtections = foundProtections.FindAll(p => p != "ActiveMARK");
+            }
+
+            // Cactus Data Shield
+            if (foundProtections.Exists(p => Regex.IsMatch(p, @"Cactus Data Shield [0-9]{3} .+", RegexOptions.Compiled))
+                && foundProtections.Exists(p => p == "Cactus Data Shield 200"))
+            {
+                foundProtections = foundProtections.FindAll(p => p != "Cactus Data Shield 200");
+            }
+
+            // Cactus Data Shield / SafeDisc
+            if (foundProtections.Exists(p => p == "Cactus Data Shield 300 (Confirm presence of other CDS-300 files)"))
+            {
+                foundProtections = foundProtections
+                    .FindAll(p => p != "Cactus Data Shield 300 (Confirm presence of other CDS-300 files)");
+
+                if (foundProtections.Exists(p => !p.StartsWith("SafeDisc")))
+                    foundProtections.Add("Cactus Data Shield 300");
+            }
+
+            // CD-Cops
+            if (foundProtections.Exists(p => p == "CD-Cops")
+                && foundProtections.Exists(p => p.StartsWith("CD-Cops")
+                    && p.Length > "CD-Cops".Length))
+            {
+                foundProtections = foundProtections.FindAll(p => p != "CD-Cops");
+            }
+
+            // Electronic Arts
+            if (foundProtections.Exists(p => p == "EA DRM Protection")
+                && foundProtections.Exists(p => p.StartsWith("EA DRM Protection")
+                    && p.Length > "EA DRM Protection".Length))
+            {
+                foundProtections = foundProtections.FindAll(p => p != "EA DRM Protection");
+            }
+
+            // Games for Windows LIVE
+            if (foundProtections.Exists(p => p == "Games for Windows LIVE")
+                && foundProtections.Exists(p => p.StartsWith("Games for Windows LIVE")
+                    && !p.Contains("Zero Day Piracy Protection")
+                    && p.Length > "Games for Windows LIVE".Length))
+            {
+                foundProtections = foundProtections.FindAll(p => p != "Games for Windows LIVE");
+            }
+
+            // Impulse Reactor
+            if (foundProtections.Exists(p => p.StartsWith("Impulse Reactor Core Module"))
+                && foundProtections.Exists(p => p == "Impulse Reactor"))
+            {
+                foundProtections = foundProtections.FindAll(p => p != "Impulse Reactor");
+            }
+
+            // JoWood X-Prot
+            if (foundProtections.Exists(p => p.StartsWith("JoWood X-Prot")))
+            {
+                if (foundProtections.Exists(p => Regex.IsMatch(p, @"JoWood X-Prot [0-9]\.[0-9]\.[0-9]\.[0-9]{2}", RegexOptions.Compiled)))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "JoWood X-Prot")
+                        .FindAll(p => p != "JoWood X-Prot v1.0-v1.3")
+                        .FindAll(p => p != "JoWood X-Prot v1.4+")
+                        .FindAll(p => p != "JoWood X-Prot v2");
+                }
+                else if (foundProtections.Exists(p => p == "JoWood X-Prot v2"))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "JoWood X-Prot")
+                        .FindAll(p => p != "JoWood X-Prot v1.0-v1.3")
+                        .FindAll(p => p != "JoWood X-Prot v1.4+");
+                }
+                else if (foundProtections.Exists(p => p == "JoWood X-Prot v1.4+"))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "JoWood X-Prot")
+                        .FindAll(p => p != "JoWood X-Prot v1.0-v1.3");
+                }
+                else if (foundProtections.Exists(p => p == "JoWood X-Prot v1.0-v1.3"))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "JoWood X-Prot");
+                }
+            }
+
+            // LaserLok
+            // TODO: Figure this one out
+
+            // ProtectDISC / VOB ProtectCD/DVD
+            // TODO: Figure this one out
+
+            // SafeCast
+            // TODO: Figure this one out
+
+            // SafeDisc
+            if (foundProtections.Exists(p => p.StartsWith("SafeDisc")))
+            {
+                // Confirmed this set of checks works with Redump entries 10430, 11347, 13230, 18614, 28257, 31149, 31824, 52606, 57721, 58455,
+                // 58573, 62935, 63941, 64255, 65569, 66005, 70504, 73502, 74520, 78048, 79729, 83468, 98589, and 101261.
+
+                // Best case scenario for SafeDisc 2+: A full SafeDisc version is found in a line starting with "Macrovision Protected Application".
+                // All other SafeDisc detections can be safely scrubbed.
+                if (foundProtections.Exists(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)
+                        && p.Contains("Macrovision Protected Application")
+                        && !p.Contains("SRV Tool APP")))
+                {
+                    foundProtections = foundProtections.FindAll(p => !p.StartsWith("Macrovision Protection File"))
+                        .FindAll(p => !p.StartsWith("Macrovision Security Driver"))
+                        .FindAll(p => !p.Contains("SRV Tool APP"))
+                        .FindAll(p => p != "SafeDisc")
+                        .FindAll(p => !p.StartsWith("Macrovision Protected Application [Version Expunged]"))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}-[0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}\+", RegexOptions.Compiled))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}\/4\+", RegexOptions.Compiled))
+                        .FindAll(p => p != "SafeDisc 1/Lite")
+                        .FindAll(p => p != "SafeDisc 2+")
+                        .FindAll(p => p != "SafeDisc 3+ (DVD)");
+                    foundProtections = foundProtections.ConvertAll(p => p
+                            .Replace("Macrovision Protected Application, ", string.Empty)
+                            .Replace(", Macrovision Protected Application", string.Empty));
+                }
+
+                // Next best case for SafeDisc 2+: A full SafeDisc version is found from the "SafeDisc SRV Tool APP".
+                else if (foundProtections.Exists(p => Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)
+                        && p.Contains("Macrovision Protected Application")
+                        && p.Contains("SRV Tool APP")))
+                {
+                    foundProtections = foundProtections.FindAll(p => !p.StartsWith("Macrovision Protection File"))
+                        .FindAll(p => !p.StartsWith("Macrovision Security Driver"))
+                        .FindAll(p => p != "SafeDisc")
+                        .FindAll(p => !p.StartsWith("Macrovision Protected Application [Version Expunged]"))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}-[0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}\+", RegexOptions.Compiled))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}\/4\+", RegexOptions.Compiled))
+                        .FindAll(p => p != "SafeDisc 1/Lite")
+                        .FindAll(p => p != "SafeDisc 2+")
+                        .FindAll(p => p != "SafeDisc 3+ (DVD)");
+                }
+
+                // Covers specific edge cases where older drivers are erroneously placed in discs with a newer version of SafeDisc, and the specific SafeDisc version is expunged.
+                else if (foundProtections.Exists(p => Regex.IsMatch(p, @"SafeDisc [1-2]\.[0-9]{2}\.[0-9]{3}-[1-2]\.[0-9]{2}\.[0-9]{3}$", RegexOptions.Compiled)
+                        || Regex.IsMatch(p, @"SafeDisc [1-2]\.[0-9]{2}\.[0-9]{3}$", RegexOptions.Compiled))
+                    && foundProtections.Exists(p => p == "SafeDisc 3+ (DVD)"))
+                {
+                    foundProtections = foundProtections.FindAll(p => !p.StartsWith("Macrovision Protection File"))
+                    .FindAll(p => !p.StartsWith("Macrovision Protected Application [Version Expunged]"))
+                    .FindAll(p => !p.StartsWith("Macrovision Security Driver"))
+                    .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [1-2]\.[0-9]{2}\.[0-9]{3}\+", RegexOptions.Compiled))
+                    .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [1-2]\.[0-9]{2}\.[0-9]{3}-[1-2]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled))
+                    .FindAll(p => p != "SafeDisc")
+                    .FindAll(p => p != "SafeDisc 1/Lite")
+                    .FindAll(p => p != "SafeDisc 2+");
+                }
+
+                // Best case for SafeDisc 1.X: A full SafeDisc version is found that isn't part of a version range. 
+                else if (foundProtections.Exists(p => Regex.IsMatch(p, @"SafeDisc 1\.[0-9]{2}\.[0-9]{3}$", RegexOptions.Compiled)
+                        && !Regex.IsMatch(p, @"SafeDisc 1\.[0-9]{2}\.[0-9]{3}-[0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)))
+                {
+                    foundProtections = foundProtections.FindAll(p => !p.StartsWith("Macrovision Protection File"))
+                        .FindAll(p => !p.StartsWith("Macrovision Security Driver"))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}-[0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}\+", RegexOptions.Compiled))
+                        .FindAll(p => p != "SafeDisc")
+                        .FindAll(p => p != "SafeDisc 1")
+                        .FindAll(p => p != "SafeDisc 1/Lite");
+                }
+
+                // Next best case for SafeDisc 1: A SafeDisc version range is found from "SECDRV.SYS".
+                else if (foundProtections.Exists(p => p.StartsWith("Macrovision Security Driver")
+                        && Regex.IsMatch(p, @"SafeDisc 1\.[0-9]{2}\.[0-9]{3}-[1-2]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled)
+                        || Regex.IsMatch(p, @"SafeDisc 1\.[0-9]{2}\.[0-9]{3}$")))
+                {
+                    foundProtections = foundProtections.FindAll(p => !p.StartsWith("Macrovision Protection File"))
+                        .FindAll(p => !p.StartsWith("Macrovision Protected Application [Version Expunged]"))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}\+", RegexOptions.Compiled))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc 1\.[0-9]{2}\.[0-9]{3}-[0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled))
+                        .FindAll(p => p != "SafeDisc")
+                        .FindAll(p => p != "SafeDisc 1")
+                        .FindAll(p => p != "SafeDisc 1/Lite");
+                    foundProtections = foundProtections.ConvertAll(p => p.StartsWith("Macrovision Security Driver") && p.Split('/').Length > 1
+                        ? p.Split('/')[1].TrimStart()
+                        : p);
+                }
+
+                // Next best case for SafeDisc 2+: A SafeDisc version range is found from "SECDRV.SYS".
+                else if (foundProtections.Exists(p => p.StartsWith("Macrovision Security Driver")))
+                {
+                    foundProtections = foundProtections.FindAll(p => !p.StartsWith("Macrovision Protection File"))
+                        .FindAll(p => !p.StartsWith("Macrovision Protected Application [Version Expunged]"))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}\+", RegexOptions.Compiled))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc 1\.[0-9]{2}\.[0-9]{3}-[0-9]\.[0-9]{2}\.[0-9]{3}", RegexOptions.Compiled))
+                        .FindAll(p => p != "SafeDisc")
+                        .FindAll(p => p != "SafeDisc 1")
+                        .FindAll(p => p != "SafeDisc 1/Lite")
+                        .FindAll(p => p != "SafeDisc 2+")
+                        .FindAll(p => p != "SafeDisc 3+ (DVD)");
+                    foundProtections = foundProtections.ConvertAll(p => p.StartsWith("Macrovision Security Driver") && p.Split('/').Length > 1
+                        ? p.Split('/')[1].TrimStart()
+                        : p);
+                }
+
+                // Only SafeDisc Lite is found.
+                else if (foundProtections.Exists(p => p == "SafeDisc Lite"))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "SafeDisc")
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc 1\.[0-9]{2}\.[0-9]{3}-1\.[0-9]{2}\.[0-9]{3}\/Lite", RegexOptions.Compiled));
+                }
+
+                // Only SafeDisc 3+ is found.
+                else if (foundProtections.Exists(p => p == "SafeDisc 3+ (DVD)"))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "SafeDisc")
+                        .FindAll(p => p != "SafeDisc 2+")
+                        .FindAll(p => !p.StartsWith("Macrovision Protection File"))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}\+", RegexOptions.Compiled));
+                }
+
+                // Only SafeDisc 2+ is found.
+                else if (foundProtections.Exists(p => p == "SafeDisc 2+"))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "SafeDisc")
+                        .FindAll(p => !p.StartsWith("Macrovision Protection File"))
+                        .FindAll(p => !Regex.IsMatch(p, @"SafeDisc [0-9]\.[0-9]{2}\.[0-9]{3}\+", RegexOptions.Compiled));
+                }
+            }
+
+            // SecuROM
+            if (foundProtections.Exists(p => p.StartsWith("SecuROM Release Control")))
+            {
+                foundProtections = foundProtections.FindAll(p => !p.StartsWith("SecuROM Release Control"));
+                foundProtections.Add("SecuROM Release Control");
+            }
+
+            // SolidShield
+            // TODO: Figure this one out
+
+            // StarForce
+            if (foundProtections.Exists(p => p.StartsWith("StarForce")))
+            {
+                if (foundProtections.Exists(p => Regex.IsMatch(p, @"StarForce [0-9]+\..+", RegexOptions.Compiled)))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "StarForce")
+                        .FindAll(p => p != "StarForce 3-5")
+                        .FindAll(p => p != "StarForce 5")
+                        .FindAll(p => p != "StarForce 5 [Protected Module]");
+                }
+                else if (foundProtections.Exists(p => p == "StarForce 5 [Protected Module]"))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "StarForce")
+                        .FindAll(p => p != "StarForce 3-5")
+                        .FindAll(p => p != "StarForce 5");
+                }
+                else if (foundProtections.Exists(p => p == "StarForce 5"))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "StarForce")
+                        .FindAll(p => p != "StarForce 3-5");
+                }
+                else if (foundProtections.Exists(p => p == "StarForce 3-5"))
+                {
+                    foundProtections = foundProtections.FindAll(p => p != "StarForce");
+                }
+            }
+
+            // Sysiphus
+            if (foundProtections.Exists(p => p == "Sysiphus")
+                && foundProtections.Exists(p => p.StartsWith("Sysiphus") && p.Length > "Sysiphus".Length))
+            {
+                foundProtections = foundProtections.FindAll(p => p != "Sysiphus");
+            }
+
+            // TAGES
+            // TODO: Figure this one out
+
+            // XCP
+            if (foundProtections.Exists(p => p == "XCP")
+                && foundProtections.Exists(p => p.StartsWith("XCP") && p.Length > "XCP".Length))
+            {
+                foundProtections = foundProtections.FindAll(p => p != "XCP");
+            }
+
+            // Sort and return the protections
+            foundProtections.Sort();
+            return string.Join(", ", [.. foundProtections]);
+        }
+    }
+}

MPF.Frontend/ViewModels/CheckDumpViewModel.cs

@@ -0,0 +1,456 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.IO;
+using System.Threading.Tasks;
+using BinaryObjectScanner;
+using MPF.Frontend.ComboBoxItems;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend.ViewModels
+{
+    /// <summary>
+    /// Constructor
+    /// </summary>
+    public class CheckDumpViewModel : INotifyPropertyChanged
+    {
+        #region Fields
+
+        /// <summary>
+        /// Access to the current options
+        /// </summary>
+        public Options Options
+        {
+            get => _options;
+        }
+        private readonly Options _options;
+
+        /// <summary>
+        /// Indicates if SelectionChanged events can be executed
+        /// </summary>
+        public bool CanExecuteSelectionChanged { get; private set; } = false;
+
+        /// <inheritdoc/>
+        public event PropertyChangedEventHandler? PropertyChanged;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Currently selected system value
+        /// </summary>
+        public RedumpSystem? CurrentSystem
+        {
+            get => _currentSystem;
+            set
+            {
+                _currentSystem = value;
+                TriggerPropertyChanged(nameof(CurrentSystem));
+            }
+        }
+        private RedumpSystem? _currentSystem;
+
+        /// <summary>
+        /// Indicates the status of the system type combo box
+        /// </summary>
+        public bool SystemTypeComboBoxEnabled
+        {
+            get => _systemTypeComboBoxEnabled;
+            set
+            {
+                _systemTypeComboBoxEnabled = value;
+                TriggerPropertyChanged(nameof(SystemTypeComboBoxEnabled));
+            }
+        }
+        private bool _systemTypeComboBoxEnabled;
+
+        /// <summary>
+        /// Currently provided input path
+        /// </summary>
+        public string? InputPath
+        {
+            get => _inputPath;
+            set
+            {
+                _inputPath = value;
+                TriggerPropertyChanged(nameof(InputPath));
+            }
+        }
+        private string? _inputPath;
+
+        /// <summary>
+        /// Indicates the status of the input path text box
+        /// </summary>
+        public bool InputPathTextBoxEnabled
+        {
+            get => _inputPathTextBoxEnabled;
+            set
+            {
+                _inputPathTextBoxEnabled = value;
+                TriggerPropertyChanged(nameof(InputPathTextBoxEnabled));
+            }
+        }
+        private bool _inputPathTextBoxEnabled;
+
+        /// <summary>
+        /// Indicates the status of the input path browse button
+        /// </summary>
+        public bool InputPathBrowseButtonEnabled
+        {
+            get => _inputPathBrowseButtonEnabled;
+            set
+            {
+                _inputPathBrowseButtonEnabled = value;
+                TriggerPropertyChanged(nameof(InputPathBrowseButtonEnabled));
+            }
+        }
+        private bool _inputPathBrowseButtonEnabled;
+
+        /// <summary>
+        /// Currently selected dumping program
+        /// </summary>
+        public InternalProgram CurrentProgram
+        {
+            get => _currentProgram;
+            set
+            {
+                _currentProgram = value;
+                TriggerPropertyChanged(nameof(CurrentProgram));
+            }
+        }
+        private InternalProgram _currentProgram;
+
+        /// <summary>
+        /// Indicates the status of the dumping program combo box
+        /// </summary>
+        public bool DumpingProgramComboBoxEnabled
+        {
+            get => _dumpingProgramComboBoxEnabled;
+            set
+            {
+                _dumpingProgramComboBoxEnabled = value;
+                TriggerPropertyChanged(nameof(DumpingProgramComboBoxEnabled));
+            }
+        }
+        private bool _dumpingProgramComboBoxEnabled;
+
+        /// <summary>
+        /// Currently displayed status
+        /// </summary>
+        public string Status
+        {
+            get => _status;
+            set
+            {
+                _status = value;
+                TriggerPropertyChanged(nameof(Status));
+                TriggerPropertyChanged(nameof(StatusFirstLine));
+            }
+        }
+        private string _status;
+
+        /// <summary>
+        /// Currently displayed status trimmed to one line
+        /// </summary>
+        public string StatusFirstLine
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(Status))
+                    return string.Empty;
+
+                var statusLines = Status.Split('\n');
+                if (statusLines.Length > 1)
+                    return statusLines[0] + " (...)";
+
+                return statusLines[0];
+            }
+        }
+
+        /// <summary>
+        /// Indicates the status of the check dump button
+        /// </summary>
+        public bool CheckDumpButtonEnabled
+        {
+            get => _checkDumpButtonEnabled;
+            set
+            {
+                _checkDumpButtonEnabled = value;
+                TriggerPropertyChanged(nameof(CheckDumpButtonEnabled));
+            }
+        }
+        private bool _checkDumpButtonEnabled;
+
+        /// <summary>
+        /// Indicates the status of the cancel button
+        /// </summary>
+        public bool CancelButtonEnabled
+        {
+            get => _cancelButtonEnabled;
+            set
+            {
+                _cancelButtonEnabled = value;
+                TriggerPropertyChanged(nameof(CancelButtonEnabled));
+            }
+        }
+        private bool _cancelButtonEnabled;
+
+        #endregion
+
+        #region List Properties
+
+        /// <summary>
+        /// Current list of supported system profiles
+        /// </summary>
+        public List<RedumpSystemComboBoxItem> Systems
+        {
+            get => _systems;
+            set
+            {
+                _systems = value;
+                TriggerPropertyChanged(nameof(Systems));
+            }
+        }
+        private List<RedumpSystemComboBoxItem> _systems;
+
+        /// <summary>
+        /// List of available internal programs
+        /// </summary>
+        public List<Element<InternalProgram>> InternalPrograms
+        {
+            get => _internalPrograms;
+            set
+            {
+                _internalPrograms = value;
+                TriggerPropertyChanged(nameof(InternalPrograms));
+            }
+        }
+        private List<Element<InternalProgram>> _internalPrograms;
+
+        #endregion
+
+        /// <summary>
+        /// Constructor for pure view model
+        /// </summary>
+        public CheckDumpViewModel()
+        {
+            _options = OptionsLoader.LoadFromConfig();
+            _internalPrograms = [];
+            _inputPath = string.Empty;
+            _systems = [];
+            _status = string.Empty;
+
+            SystemTypeComboBoxEnabled = true;
+            InputPathTextBoxEnabled = true;
+            InputPathBrowseButtonEnabled = true;
+            DumpingProgramComboBoxEnabled = true;
+            CheckDumpButtonEnabled = false;
+            CancelButtonEnabled = true;
+
+            Systems = RedumpSystemComboBoxItem.GenerateElements();
+            InternalPrograms = [];
+
+            PopulateInternalPrograms();
+            EnableEventHandlers();
+        }
+
+        #region Property Updates
+
+        /// <summary>
+        /// Trigger a property changed event
+        /// </summary>
+        private void TriggerPropertyChanged(string propertyName)
+        {
+            // Disable event handlers temporarily
+            bool cachedCanExecuteSelectionChanged = CanExecuteSelectionChanged;
+            DisableEventHandlers();
+
+            // If the property change event is initialized
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+
+            // Reenable event handlers, if necessary
+            if (cachedCanExecuteSelectionChanged) EnableEventHandlers();
+        }
+
+        #endregion
+
+        #region UI Commands
+
+        /// <summary>
+        /// Change the currently selected system
+        /// </summary>
+        public void ChangeSystem()
+        {
+            CheckDumpButtonEnabled = ShouldEnableCheckDumpButton();
+        }
+
+        /// <summary>
+        /// Change the currently selected dumping program
+        /// </summary>
+        public void ChangeDumpingProgram()
+        {
+            CheckDumpButtonEnabled = ShouldEnableCheckDumpButton();
+        }
+
+        /// <summary>
+        /// Change the currently selected input path
+        /// </summary>
+        public void ChangeInputPath()
+        {
+            CheckDumpButtonEnabled = ShouldEnableCheckDumpButton();
+        }
+
+        #endregion
+
+        #region UI Control
+
+        /// <summary>
+        /// Enables all UI elements that should be enabled
+        /// </summary>
+        private void EnableUIElements()
+        {
+            SystemTypeComboBoxEnabled = true;
+            InputPathTextBoxEnabled = true;
+            InputPathBrowseButtonEnabled = true;
+            DumpingProgramComboBoxEnabled = true;
+            CheckDumpButtonEnabled = ShouldEnableCheckDumpButton();
+            CancelButtonEnabled = true;
+        }
+
+        /// <summary>
+        /// Disables all UI elements
+        /// </summary>
+        private void DisableUIElements()
+        {
+            SystemTypeComboBoxEnabled = false;
+            InputPathTextBoxEnabled = false;
+            InputPathBrowseButtonEnabled = false;
+            DumpingProgramComboBoxEnabled = false;
+            CheckDumpButtonEnabled = false;
+            CancelButtonEnabled = false;
+        }
+
+        #endregion
+
+        #region Population
+
+        /// <summary>
+        /// Populate media type according to system type
+        /// </summary>
+        private void PopulateInternalPrograms()
+        {
+            // Disable other UI updates
+            bool cachedCanExecuteSelectionChanged = CanExecuteSelectionChanged;
+            DisableEventHandlers();
+
+            // Get the current internal program
+            InternalProgram internalProgram = Options.InternalProgram;
+
+            // Create a static list of supported Check programs, not everything
+            var internalPrograms = new List<InternalProgram> { InternalProgram.Redumper, InternalProgram.Aaru, InternalProgram.DiscImageCreator, InternalProgram.CleanRip, InternalProgram.PS3CFW, InternalProgram.UmdImageCreator, InternalProgram.XboxBackupCreator };
+            InternalPrograms = internalPrograms.ConvertAll(ip => new Element<InternalProgram>(ip));
+
+            // Select the current default dumping program
+            int currentIndex = InternalPrograms.FindIndex(m => m == internalProgram);
+            CurrentProgram = (currentIndex > -1 ? InternalPrograms[currentIndex].Value : InternalPrograms[0].Value);
+
+            // Reenable event handlers, if necessary
+            if (cachedCanExecuteSelectionChanged) EnableEventHandlers();
+        }
+
+        #endregion
+
+        #region UI Functionality
+
+        private bool ShouldEnableCheckDumpButton()
+        {
+            return CurrentSystem != null && !string.IsNullOrEmpty(InputPath);
+        }
+
+        /// <summary>
+        /// Enable all textbox and combobox event handlers
+        /// </summary>
+        private void EnableEventHandlers()
+        {
+            CanExecuteSelectionChanged = true;
+        }
+
+        /// <summary>
+        /// Disable all textbox and combobox event handlers
+        /// </summary>
+        private void DisableEventHandlers()
+        {
+            CanExecuteSelectionChanged = false;
+        }
+
+        #endregion
+
+        #region MPF.Check
+
+        /// <summary>
+        /// Performs MPF.Check functionality
+        /// </summary>
+        /// <returns>An error message if failed, otherwise string.Empty/null</returns>
+        public async Task<ResultEventArgs> CheckDump(ProcessUserInfoDelegate processUserInfo)
+        {
+            if (string.IsNullOrEmpty(InputPath))
+                return ResultEventArgs.Failure("Invalid Input path");
+
+            if (!File.Exists(InputPath!.Trim('"')))
+                return ResultEventArgs.Failure("Input Path is not a valid file");
+
+            // Disable UI while Check is running
+            DisableUIElements();
+            bool cachedCanExecuteSelectionChanged = CanExecuteSelectionChanged;
+            DisableEventHandlers();
+
+            // Get progress indicators
+            var resultProgress = new Progress<ResultEventArgs>();
+            resultProgress.ProgressChanged += ProgressUpdated;
+            var protectionProgress = new Progress<ProtectionProgress>();
+            protectionProgress.ProgressChanged += ProgressUpdated;
+
+            // Populate an environment
+            var env = new DumpEnvironment(Options,
+                Path.GetFullPath(InputPath.Trim('"')),
+                null,
+                CurrentSystem,
+                CurrentProgram);
+            env.SetProcessor();
+
+            // Finally, attempt to do the output dance
+            var result = await env.VerifyAndSaveDumpOutput(
+                resultProgress: resultProgress,
+                protectionProgress: protectionProgress,
+                processUserInfo: processUserInfo);
+
+            // Reenable UI and event handlers, if necessary
+            EnableUIElements();
+            if (cachedCanExecuteSelectionChanged)
+                EnableEventHandlers();
+
+            return result;
+        }
+
+        /// <summary>
+        /// Handler for Result ProgressChanged event
+        /// </summary>
+        private void ProgressUpdated(object? sender, ResultEventArgs value)
+        {
+            Status = value?.Message ?? string.Empty;
+        }
+
+        /// <summary>
+        /// Handler for ProtectionProgress ProgressChanged event
+        /// </summary>
+        private void ProgressUpdated(object? sender, ProtectionProgress value)
+        {
+            string message = $"{value.Percentage * 100:N2}%: {value.Filename} - {value.Protection}";
+            Status = message;
+        }
+
+        #endregion
+    }
+}