Bump version

* Pregap start option

* Fix DriveType names

* Fix options window

* Update changelist

.github/ISSUE_TEMPLATE/feature-request.md

@@ -9,7 +9,7 @@ assignees: mnadareski
 
 **Before You Submit**
 
-- Remember to try the [latest WIP build](https://ci.appveyor.com/project/mnadareski/mpf/build/artifacts) to see if the feature already exists.
+- 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.
 

.github/ISSUE_TEMPLATE/informational.md

@@ -9,7 +9,7 @@ assignees: mnadareski
 
 **Before You Submit**
 
-- Remember to try the [latest WIP build](https://ci.appveyor.com/project/mnadareski/mpf/build/artifacts) to see if the feature already exists.
+- 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.
 

.github/ISSUE_TEMPLATE/issue-report.md

@@ -9,7 +9,7 @@ assignees: mnadareski
 
 **Before You Submit**
 
-- Remember to try the [latest WIP build](https://ci.appveyor.com/project/mnadareski/mpf/build/artifacts) to see if the issue has already been addressed.
+- 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.
@@ -25,8 +25,7 @@ What version are you using?
 **Build**
 What runtime version are you using?
 
-- [ ] .NET 6.0 running on (Operating System)
-- [ ] .NET 8.0 running on (Operating System)
+- [ ] .NET 10 running on (Operating System)
 
 **Describe the issue**
 A clear and concise description of what the bug is.

.github/workflows/build_and_test.yml

@@ -0,0 +1,59 @@
+name: Build and Test
+
+on:
+    push:
+        branches: ["master"]
+
+jobs:
+    build:
+        runs-on: ubuntu-latest
+
+        steps:
+            - name: Free Disk Space (Ubuntu)
+              uses: jlumbroso/free-disk-space@v1.3.1
+              with:
+                  dotnet: false
+
+            - uses: actions/checkout@v5
+              with:
+                  fetch-depth: 0
+
+            - name: Setup .NET
+              uses: actions/setup-dotnet@v5
+              with:
+                  dotnet-version: |
+                      8.0.x
+                      9.0.x
+                      10.0.x
+
+            - name: Run tests
+              run: dotnet test
+
+            - name: Run publish script
+              run: ./publish-nix.sh -dp
+
+            - name: Update rolling tag
+              run: |
+                  git config user.name "github-actions[bot]"
+                  git config user.email "github-actions[bot]@users.noreply.github.com"
+                  git tag -f rolling
+                  git push origin :refs/tags/rolling || true
+                  git push origin rolling --force
+
+            - name: Upload to rolling
+              uses: ncipollo/release-action@v1.20.0
+              with:
+                  allowUpdates: True
+                  artifacts: "*.nupkg,*.snupkg,*.zip"
+                  body: "Last built commit: ${{ github.sha }}
+
+                      ## UI Builds
+
+                      [Windows x64 UI Release](https://github.com/SabreTools/MPF/releases/download/rolling/MPF.UI_net10.0-windows_win-x64_release.zip)
+
+                      [Windows x64 UI Debug](https://github.com/SabreTools/MPF/releases/download/rolling/MPF.UI_net10.0-windows_win-x64_debug.zip)"
+                  name: "Rolling Release"
+                  prerelease: True
+                  replacesArtifacts: True
+                  tag: "rolling"
+                  updateOnlyUnreleased: True

.github/workflows/build_check.yml

@@ -1,50 +0,0 @@
-name: MPF Check
-
-on:
-  push:
-    branches: [ "master" ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        project: [MPF.Check]
-        runtime: [win-x86, win-x64, win-arm64, linux-x64, linux-arm64, osx-x64, osx-arm64]
-        framework: [net8.0] #[net20, net35, net40, net452, net472, net48, netcoreapp3.1, net5.0, net6.0, net7.0, net8.0]
-
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Setup .NET
-      uses: actions/setup-dotnet@v4
-      with:
-        dotnet-version: 8.0.x
-        
-    - name: Restore dependencies
-      run: dotnet restore
-      
-    - name: Build
-      run: dotnet publish ${{ matrix.project }}/${{ matrix.project }}.csproj -f ${{ matrix.framework }} -r ${{ matrix.runtime }} -c Debug --self-contained true --version-suffix ${{ github.sha }} ${{ (startsWith(matrix.framework, 'net5') || startsWith(matrix.framework, 'net6') || startsWith(matrix.framework, 'net7') || startsWith(matrix.framework, 'net8')) && '-p:PublishSingleFile=true' || ''}}
-        
-    - name: Archive build
-      run: zip -r ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip ${{ matrix.project }}/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/
-        
-    - name: Upload build
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug
-        path: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip
-
-    - name: Upload to rolling
-      uses: ncipollo/release-action@v1.14.0
-      with:
-        allowUpdates: True
-        artifacts: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip
-        body: 'Last built commit: ${{ github.sha }}'
-        name: 'Rolling Release'
-        prerelease: True
-        replacesArtifacts: True
-        tag: "rolling"
-        updateOnlyUnreleased: True

.github/workflows/build_cli.yml

@@ -1,50 +0,0 @@
-name: MPF CLI
-
-on:
-  push:
-    branches: [ "master" ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        project: [MPF.CLI]
-        runtime: [win-x86, win-x64, win-arm64, linux-x64, linux-arm64, osx-x64, osx-arm64]
-        framework: [net8.0] #[net20, net35, net40, net452, net472, net48, netcoreapp3.1, net5.0, net6.0, net7.0, net8.0]
-
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Setup .NET
-      uses: actions/setup-dotnet@v4
-      with:
-        dotnet-version: 8.0.x
-        
-    - name: Restore dependencies
-      run: dotnet restore
-      
-    - name: Build
-      run: dotnet publish ${{ matrix.project }}/${{ matrix.project }}.csproj -f ${{ matrix.framework }} -r ${{ matrix.runtime }} -c Debug --self-contained true --version-suffix ${{ github.sha }} ${{ (startsWith(matrix.framework, 'net5') || startsWith(matrix.framework, 'net6') || startsWith(matrix.framework, 'net7') || startsWith(matrix.framework, 'net8')) && '-p:PublishSingleFile=true' || ''}}
-        
-    - name: Archive build
-      run: zip -r ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip ${{ matrix.project }}/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/
-        
-    - name: Upload build
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug
-        path: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip
-
-    - name: Upload to rolling
-      uses: ncipollo/release-action@v1.14.0
-      with:
-        allowUpdates: True
-        artifacts: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip
-        body: 'Last built commit: ${{ github.sha }}'
-        name: 'Rolling Release'
-        prerelease: True
-        replacesArtifacts: True
-        tag: "rolling"
-        updateOnlyUnreleased: True

.github/workflows/build_nupkg.yml

@@ -1,61 +0,0 @@
-name: Nuget Pack
-
-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: 8.0.x
-        
-    - name: Restore dependencies
-      run: dotnet restore
-      
-    - name: Pack
-      run: dotnet pack
-
-    - name: Upload Execution Contexts package
-      uses: actions/upload-artifact@v4
-      with:
-        name: 'Execution Contexts Package'
-        path: 'MPF.ExecutionContexts/bin/Release/*.nupkg'
-
-    - name: Upload Execution Contexts to rolling
-      uses: ncipollo/release-action@v1.14.0
-      with:
-        allowUpdates: True
-        artifacts: 'MPF.ExecutionContexts/bin/Release/*.nupkg'
-        body: 'Last built commit: ${{ github.sha }}'
-        name: 'Rolling Release'
-        prerelease: True
-        replacesArtifacts: True
-        tag: "rolling"
-        updateOnlyUnreleased: True
-
-    - name: Upload Processors package
-      uses: actions/upload-artifact@v4
-      with:
-        name: 'Processors Package'
-        path: 'MPF.Processors/bin/Release/*.nupkg'
-
-    - name: Upload Execution Contexts to rolling
-      uses: ncipollo/release-action@v1.14.0
-      with:
-        allowUpdates: True
-        artifacts: 'MPF.Processors/bin/Release/*.nupkg'
-        body: 'Last built commit: ${{ github.sha }}'
-        name: 'Rolling Release'
-        prerelease: True
-        replacesArtifacts: True
-        tag: "rolling"
-        updateOnlyUnreleased: True

.github/workflows/build_ui.yml

@@ -1,64 +0,0 @@
-name: MPF UI
-
-on:
-  push:
-    branches: [ "master" ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        project: [MPF.UI]
-        runtime: [win-x86, win-x64]
-        framework: [net8.0-windows] #[net40, net452, net472, net48, netcoreapp3.1, net5.0-windows, net6.0-windows, net7.0-windows, net8.0-windows]
-
-    steps:
-    - uses: actions/checkout@v4
-    
-    - name: Setup .NET
-      uses: actions/setup-dotnet@v4
-      with:
-        dotnet-version: 8.0.x
-        
-    - name: Restore dependencies
-      run: dotnet restore
-      
-    - name: Build
-      run: dotnet publish ${{ matrix.project }}/${{ matrix.project }}.csproj -f ${{ matrix.framework }} -r ${{ matrix.runtime }} -c Debug --self-contained true --version-suffix ${{ github.sha }} ${{ (startsWith(matrix.framework, 'net5') || startsWith(matrix.framework, 'net6') || startsWith(matrix.framework, 'net7') || startsWith(matrix.framework, 'net8')) && '-p:PublishSingleFile=true' || ''}}
-      
-    - name: Bundle DiscImageCreator
-      run: |
-        wget https://github.com/user-attachments/files/15521936/DiscImageCreator_20240601.zip
-        unzip -u DiscImageCreator_20240601.zip
-        mkdir -p MPF.UI/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/Programs/Creator
-        mv Release_ANSI/* MPF.UI/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/Programs/Creator/
-
-    - name: Bundle Redumper
-      run: |
-        wget https://github.com/superg/redumper/releases/download/build_371/redumper-2024.05.27_build371-win64.zip
-        unzip redumper-2024.05.27_build371-win64.zip
-        mkdir -p MPF.UI/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/Programs/Redumper
-        mv redumper-2024.05.27_build371-win64/bin/redumper.exe MPF.UI/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/Programs/Redumper/
-
-    - name: Archive build
-      run: zip -r ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip ${{ matrix.project }}/bin/Debug/${{ matrix.framework }}/${{ matrix.runtime }}/publish/
-        
-    - name: Upload build
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug
-        path: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip
-
-    - name: Upload to rolling
-      uses: ncipollo/release-action@v1.14.0
-      with:
-        allowUpdates: True
-        artifacts: ${{ matrix.project }}_${{ matrix.framework }}_${{ matrix.runtime }}_debug.zip
-        body: 'Last built commit: ${{ github.sha }}'
-        name: 'Rolling Release'
-        prerelease: True
-        replacesArtifacts: True
-        tag: "rolling"
-        updateOnlyUnreleased: True

.github/workflows/check_pr.yml

@@ -3,21 +3,29 @@ name: Build PR
 on: [pull_request]
 
 jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
+    build:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Free Disk Space (Ubuntu)
+              uses: jlumbroso/free-disk-space@v1.3.1
+              with:
+                  dotnet: false
 
-    - name: Setup .NET
-      uses: actions/setup-dotnet@v4
-      with:
-        dotnet-version: 8.0.x
+            - uses: actions/checkout@v5
 
-    - name: Restore dependencies
-      run: dotnet restore
+            - name: Setup .NET
+              uses: actions/setup-dotnet@v5
+              with:
+                  dotnet-version: |
+                      8.0.x
+                      9.0.x
+                      10.0.x
 
-    - name: Build
-      run: dotnet build --no-restore
+            - name: Restore dependencies
+              run: dotnet restore
 
-    - name: Test
-      run: dotnet test --no-restore --verbosity normal
+            - 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

@@ -5,12 +5,12 @@
    "version": "0.2.0",
    "configurations": [
         {
-            "name": ".NET Core Launch (console)",
+            "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/net8.0/MPF.Check.dll",
+            "program": "${workspaceFolder}/MPF.Check/bin/Debug/net10.0/MPF.Check.dll",
             "args": [],
             "cwd": "${workspaceFolder}/MPF.Check",
             // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console
@@ -18,6 +18,34 @@
             "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/net10.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 Launch (UI)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/MPF.UI/bin/Debug/net10.0-windows/MPF.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/MPF.UI",
+            // 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",

CHANGELIST.md

@@ -1,4 +1,559 @@
-### 3.2.2 (2024-09-xx)
+### 3.6.0 (2025-11-28)
+
+- Add BCA to list of files to select in Check UI
+- Move Zstd compression helper to base processor
+- Add file merge method in CleanRip
+- Implement file merging in CleanRip
+- Support reparsing of MPF-processed outputs
+- Use WriteToFile extension for zip entries
+- Move output file implementations to separate namespace
+- Conditionally require state
+- Replace "We" comments
+- Parse XboxOne/SX Title IDs
+- Reduce chance of empty strings
+- Initial UI lang code
+- Move to enum-based model for UI language options
+- Slight cleanup to main window language handling
+- Clean up nullability
+- Clean up a bit of element work
+- Fill in some gaps
+- Add UI by default to launch
+- Continue UI translation work
+- Minor formatting cleanup
+- Ensure readers and writers dispose
+- Complete translation support
+- Add skeleton for 8 more languages
+- Add 8 more language menu items
+- Add basic translation for 8 more languages
+- Make Check flags toggle if config used
+- Add console print when Check loads from config
+- Add Ukrainian translation (superg)
+- Add list configuration commandline feature
+- Handle a provided log zip in Check operation
+- Allow files to be zipped but not deleted
+- Fix long translated strings
+- Allow placeholder files to be used in Check
+- Make .img not required for DIC outputs
+- Handle log zip path in information extraction
+- Redumper state file is not accessed
+- Fix tests broken by last commit
+- Regex outputs should not name based on pattern
+- Make log archive handling more user-apparent
+- Be selective on which systems to enable skeleton
+- Readme updates for accuracy
+- Separate out default program paths
+- Add per-OS executable names
+- Simplify first-run CLI experience
+- Change CLI first-run wording
+- Free disk space for runners
+- Possibly fix missing options string
+- Minor Spanish cleanup
+- Update RedumpLib to 1.8.0
+- Limit visibility of Compatible OS text box
+- Stop using long name for default system setting
+- Updated Polish translation
+- Fix rolling tag
+- Try to add UI links to rolling release
+- Slight tweak to automatic UI links
+- Add hidden language (NovaAurora)
+- Fix langs
+- Fix issues with path assembly
+- Clean up submission info use and log link text
+- Update Redumper to build 658
+- Pre-compress all skeletons for multi-track CDs
+- Add DVD-Video to list of copy protection scanning systems
+- Update Redumper to build 660
+- Use dated default output filenames
+- Update packages
+- Scan disc image if not multi-track
+- Scan multi-track images for protection
+- Move and rename new protection scan method
+- Path scan after image scan
+- Update Redumper to build 663
+- Name some type parameters
+- Ensure volume label is trimmed if used in filenames
+- Remove DPM identifier for StarForce Keyless
+- New Redumper Drive Pregap Start option
+- Clarify the unmounted device case
+- Add support for .NET 10
+- Update Redumper to build 665
+- Disable Zstd PKZIP outputs
+- Add commented fix for Zstd PKZIP
+- Reenable Zstd PKZIP outputs
+
+### 3.5.0 (2025-10-10)
+
+- Add failure if media type could not be determined
+- Tweaks to how failure cases are reported
+- Rename log zip on collision
+- Update packages
+- Use CommandLine library for CLI executables
+- Create interactive mode features
+- Minor cleanup around last added
+- Add placeholder command set creation
+- Reduce unnecessary shared code
+- Create and use main features for CLI and Check
+- Create and use base feature in Check
+- Create and use base feature in CLI
+- Assign inputs for interactive modes
+- Remove duplicate input declarations
+- Fix strange invocations of extension methods
+- Remove CommandOptions implementations
+- Exit early on parsing failures
+- Fix minor typo in verify inputs check
+- Allow but do not require config for Check
+- Update packages
+- More consistency in commandline programs
+- Use GC.SharpCompress as archive handling library
+- Start wiring through log compression changes
+- Fix minor issues with options loading
+- Finalize wire-through and clean up
+- Minor cleanup on interactive modes
+- Add more useful credentials inputs for Check
+- More gracefully handle "missing" media types
+- Use null or empty instead of just null
+- Guard against unzippable files
+- Fix incorrect flagging of a failed check
+- Use ZipWriterOptions instead of generic
+- Allow skeleton creation for all media types
+- Fix default value tests
+- Only allow skeleton creation for CD and DVD
+- Add preemptive new file support
+- Add preemptive helper for Zstd handling
+- Pre-compress skeleton files with Zstd
+- Fix broken file count tests
+- Pre-compress state files with Zstd
+- Use block-based reading instead of CopyTo
+- Enable skeleton output for all CLI runs
+- Fix test broken by last commit
+- Support detecting split Wii for CleanRip
+- Try to handle Windows-specific compression issue
+
+### 3.4.2 (2025-09-30)
+
+- Fix starting index for CLI
+- Fix missed package update
+- Require exact versions for build
+
+### 3.4.1 (2025-09-29)
+
+- Experiment with only showing media type box for DIC
+- Default media type box to hidden to avoid visual issues
+- Limit media type visibility further
+- Set media type visibility when options changed
+- Change label with media type visibility
+- Update media type visibility on system change
+- Return full result from dump checks
+- Fix logic from around Macrovision security driver filtering
+- Remove SkipMediaTypeDetection option, cleanup options window
+- Minor tweaks to frontend code
+- Default to CD speed range
+- Skip trying to set speeds if no drives
+- Fix tests
+- Make media type a named parameter for CLI
+- Reduction in media type use for dumping
+- Update BinaryObjectScanner to 3.4.3
+
+### 3.4.0 (2025-09-25)
+
+- Remove media type from Check Dump UI
+- Always trust the output files for processing
+- UI consistency when parameters are editable
+- Let the processor always deal with unsupported
+- Put a try/catch around GenerateArtifacts
+- Reduce preprocessing in DumpEnvironment
+- Update RedumpLib to 1.6.9
+- Treat all UMD as DL visually
+- Add CopyUpdateUrlToClipboard option
+- Fix inconsistency with newlines
+- Update Aaru to build 5.4.1
+- Fix for C2 error doubling issue (fuzz6001)
+- Update RedumpLib and LibIRD
+- Update LibIRD
+- Update redumper to build 653
+- Minor cleanup
+- Update test Nuget packages
+- Update RedumpLib to 1.7.1
+- Support multisession cache files
+- Update DIC to 20250901 (Windows/Linux only)
+- Fix UIC processing logic
+- Update RedumpLib, detect Playmaji Polymega system
+- Update redumper to b655
+- Support new versioning format in redumper (fuzz6001)
+- Add RedumperRefineSectorMode setting
+- Update BinaryObjectScanner to 3.4.0
+- Add context-sensitive protections helper method
+- Further flesh out framework
+- Add filters to handle Release Control output (Bestest)
+- Cleanup last commits, add tests
+- Update BinaryObjectScanner to 3.4.2
+- Update RedumpLib to 1.7.4
+
+### 3.3.3 (2025-07-18)
+
+- Handle layers for PS3CFW
+- Further clarify configuration requirements for CLI
+- Ignore volume labels with path separators
+- Reduce media-specific checks where unnecessary
+- Add DetermineMediaType scaffolding and tests
+- Fill out DetermineMediaType for Redumper
+- Fill out DetermineMediaType for Aaru
+- Fill out DetermineMediaType for DiscImageCreator
+- Enable Check to determine media type automatically
+- Fix missed test updates
+- Rename disc info to media info
+- Fix start index in Check
+- Use the correct base path for Check
+- Update redumper to build 611
+- IsAudio cleanup
+- IsAudio cleanup cleanup
+- Remove dead code in DIC processor
+- Set some default values for CLI
+- Address nullable default value
+- Better handling of Xbox/360, redumper build 613
+- Use reasonable default names for PlayStation systems
+- Swap PS1/2 back to original name handling
+- Only use serial for PS3/4/5 if no custom volume label
+- Fix unnecessary null assignment
+- Empty should be null (fuzz6001)
+- Remove legacy codes from info window
+- Net Yaroze only for PS1
+- Update RedumpLib to 1.6.8
+- Add new help and version flags for CLI and Check
+- Strip errant whitespace during path normalization
+- Simplify code from previous commit
+- Better handle mixed-separator paths
+- Slightly better IRD organization
+- Update redumper to build 631
+
+### 3.3.2 (2025-06-12)
+
+- Include Aaru in automatic builds
+- Update RedumpLib to 1.6.7
+- Update redumper, DriveType option, SS sanity check
+- Fix issues with last commit
+- Update tooltips/labels for controversial options
+- Add currently-hidden RetrieveMatchInformation option
+- Fix Redump default options
+- Fix tests from last commit
+- Remove unnecessary options property
+- Decouple retieval from login
+- Simplify Options naming where possible
+- Create multi-size icon
+- Fix size retrieval for Aaru
+- Update redumper to build 610
+
+### 3.3.1 (2025-05-23)
+
+- Fix typo for L1Toolstamp!.Label (bikerspade)
+- Update redumper to build 549
+- Allow max speed dumping ("0")
+- Normalize file path in CLI
+- Always write full configuration file
+- Short-circuit CLI first-run experience
+- Start defining all download URLs
+- Add all separate downloads
+- Make more paths configurable
+- Add commented placeholders instead of omitting
+- Move function definitions
+- Smarter mapping of URLs to runtimes
+- Unify download maps
+- Trailing commas caused issues
+- Add initial extraction to new functions
+- Add cleanup to download functions
+- Fix most issues in new download code
+- Fix issue with some downloads
+- Replace old download implementations
+- Enable packing programs for CLI
+- Fix minor packing issues
+- Comment download scripts more
+- Fix removing empty subdirectories
+- Add interactive mode to CLI
+- Add padding above root interactive node label
+- Clean up case-sensitivity
+- Add interactive mode to Check
+- Fix menu title in Check interactive
+- It's not dumping, it's checking
+- Make interactive mode cleaner
+- Avoid redundant redundancy
+- Allow exiting from interactive modes
+- Update RedumpLib to 1.6.5
+- Fix package reference layout
+- Update Nuget packages
+- Normalize Shift-JIS characters, when possible
+- Update to DIC 20250501
+- Update RedumpLib to 1.6.6
+- Pre-clean file path in CLI interactive mode
+- Tweak to previous commit for some build versions
+- Fix lines wiped before displayed
+- Update redumper to build 565
+- Close the log archive, if it exists
+- Support checking Redumper DAT from zip; add tests
+- Add Check warnings around overwriting and parsing
+- Clarification on some options
+- One more note about hidden settings
+- Explicitly unset Redumper speed, if needed
+- Simplify WriteOutputData path handling
+- Serialize JSON a slightly different way
+- Add newlines to pkg info printing
+- Better audio-only check
+- Minor cleanup from last commit
+- Relax PS3CFW output filename requirements
+- Fix bracket formatting from last commit
+- Fix speed dropdown with Redumper
+- Update redumper to build 585
+- Further fix speed dropdown with Redumper
+- Use null for 0 speed internally
+- Don't hash bad SS
+- Add and use status label for Check window
+- Minor Check UI improvements
+- Reset Redump errors when an INFO block is found
+- Handle error count resets in Redumper
+- Remove unnecessary conditional
+
+### 3.3.0 (2025-01-03)
+
+- Update packages
+- Add skeleton test projects for individual libraries
+- Move existing tests to new projects
+- Add BaseProcessor tests
+- Add processor base implementation tests
+- Ensure SS.bin only required for DVD
+- Update tests to account for new file count
+- Add tests around some Aaru helpers
+- Add tests around CleanRip helpers
+- Fix CleanRip test access
+- Add tests around XBC helpers
+- Fix failing XBC test
+- Perform better path emptiness checks
+- Add tests around UIC helpers
+- Add tests around PS3 CFW helpers
+- Enable test running on package and PR
+- Fix missing test data
+- Add tests around Redumper helpers
+- Add sanity check output file tests
+- Add tests around DIC helpers
+- Add safety around sidecar generation
+- Use recommended Min/Max/TryParse
+- Add tests around ProcessingTool
+- Add BaseExecutionContext tests
+- Add currently unused Input type
+- Split Input type into typed classes
+- Add flag for value being set
+- Add unused inputs to Aaru
+- Add self-formatting to Input types
+- Handle issue with old .NET
+- Let inputs read equal-separated values
+- Fix some formatting issues with Input types
+- Replace Aaru pre-command flags
+- Use string builders where possible
+- Add Aaru parameters tests
+- Replace Aaru flag values with input types
+- Add Redumper parameters tests
+- Add quotes option to string input
+- Replace Redumper flag values with input types
+- Add DIC parameters tests
+- Add unused min/max parameters for numeric inputs
+- Add Int32 array input type
+- Wire up input boundaries
+- Fix required Int32 array input
+- Ensure dumping commands are tested
+- Add tests around default values
+- Increase sleep time in queue
+- Unify queue handling in processing queue
+- Add non-tools frontend tests
+- Update RedumpLib to 1.6.1
+- Ensure consistency in frontend code
+- Ensure Redumper support matrix is consistent
+- Add FrontendTool tests
+- Update protection tool tests
+- Remove unnecessary namespace prefixes
+- Clean up original Drive tests
+- Add debug flag to publish scripts
+- Add gated program downloads to publish scripts
+- Migrate to using publish script for GHA
+- Update README to remove AppVeyor references
+- Remove unused gated using statement
+- Add alternate config location
+- Add safety check around empty config files
+- Add launch config for CLI
+- Remove unnecessary re-splitting of path
+- Always filter out game engines and packers
+- Remove now-redundant option
+- Always omit EA CD-Key
+- Add packer filtering tests
+- Simplify prefix filtering
+- Fix issue with odd quoting
+- Add DumpingParameters for DIC and Redumper
+- Better deal with volume labels
+- Fix bug with volume labels
+- Slight formatting tweaks
+- Update BOS to 3.3.2
+- Enable handling non-SS Xbox discs
+- Use proper base path for redumper output check
+- Verify securom sector count
+- Update packages
+- Simplify direct package references
+- Remove vestigial progress indicators
+- Remove non-working last line log code
+- Fix access level for log queue
+- Fix access level for log document
+- Simplify ProcessLogLine method
+- Use explicit InvokeAsync when possible
+- (EXPERIMENTAL) Skip log line queue
+- Fully remove processing queue code
+- Introduce maximum log length
+- Print PS4/PS5 app.pkg info
+- Ensure .NET versions are installed for testing
+- Remove use of psxt001
+- Minor formatting tweaks; add TODO
+- Use simpler cuesheet reader in Redumper
+- Fix now-incorrect test values
+- Better SecuROM handling for DIC and Redumper
+- Include native libraries for self-extract
+- Preserve program metadata on publish
+- Allow symbols to be packed
+- Fix important typo
+- Remove vestigial configuration file
+- Remove reference to removed file
+- Add README files for two libraries
+- Simplify output name assembly logic
+- Fix output name null edge case
+- Selectively rebuild program list
+- Use IBM PC as default system out of the box
+- Separate params checkbox from input
+- Disable more UI elements when editing
+- Ensure parameters checkbox is enabled to start
+- Fix log line for default system use
+- Retire and replace blue secret text
+- Enable tabs in input fields by default
+- Adjust row count in protection options
+- Pedantic GUI changes
+- More pendantic GUI changes
+- Remove unused progress bar
+- Disable all UI elements on protect scan
+- Account for menu items for disable/enable
+- Allow check and IRD most of the time
+- Check for partial dumps
+- Slightly reduce nesting of file pre-dump checks
+- Slightly increase nesting of file pre-dump checks
+- Improve system detection
+- Avoid unnecessary null checks
+- Pass options to process user info separately
+- Use internal options instead of external
+- Use Invoke explicitly for delegates
+- Wrap log compression in a thread
+- Do not display invalid credentials on empty
+- Tab input only needed for ringcodes
+- More fields behind RedumpCompatible option
+- Parse redumper BIG.DAT info
+- Unify DisplayUserMessage definitions
+- Clean up unused disabled warnings
+- Missed one
+- Minor UI changes
+- Hide empty partially matched list
+- Reenable XGD1 PVD reporting
+- Improve PS4/PS5 parsing
+- Don't add special field keys with no reason
+- Add pure-getkey output names for PS3CFW
+- Partially clean up PS3CFW
+- Wrap some PhysicalTool method calls
+- Minor UI and other fixes
+- Force path update if default changed
+- Force showing tooltips on disabled items
+- Update RedumpLib to 1.6.3
+- Minor UI changes to DIW
+- Be consistent with filename extensions
+- Remove unnecessary action step
+- Update copyright
+- Update BinaryObjectScanner to 3.3.4
+- Add and use internal program short names
+- Fix BinaryObjectScanner update
+- Fix short name test
+- Update RedumpLib to 1.6.4
+- Fix misunderstanding on perfect offset
+- Handle SCSI error count
+- Update to DIC 20250101
+- Fix system detection logging
+
+### 3.2.4 (2024-11-24)
+
+- Update Redumper to build 438
+- Be smarter about Linq usage
+- Add .NET 9 to target frameworks
+- Be smarter about some data types
+- Consolidate parameter string splitting
+- Fix fully matching when multiple matches found
+- Remove usages of `this.` in more places
+- Add `skeleton` to Redumper CD by default
+- Add unused "Generic" processor
+- Add Track 0/00/A/AA to Generic
+- Add IMA extension for floppy disks
+- Remove usages of `this.` from themes
+- Fix PIC parser
+- Use expanded version of split regex
+- Update packages for bugfixes
+- Fix minor efficiency issues
+- Remove usages of `this.` from UI code
+- Reduce unnecessary use of IEnumerable
+- Use List in protection formatting
+- Don't preemptively sort protections
+- Remove unncessary .NET Framework 4.0 gating
+- Improve parameters for default output path
+- Replace some uses of Regex.Replace
+- Clean up usings after last commit
+- Version gate remaining Linq statements
+- Cleanup CleanSS check
+- Fix PS3 firmware version being omitted
+- Don't add trailing spaces to BCA output
+- Add support for Redumper Xbox dumps
+
+### 3.2.3 (2024-11-06)
+
+- Update to DIC 20240901
+- Update BinaryObjectScanner to 3.1.14
+- Fix SafeDisc filtering (TheRogueArchivist)
+- Update to DIC 20241001
+- Include all DIC write offsets
+- Fix faulty offset dedupe logic
+- Change multiple offset delimiter
+- Make .NET 8 the default in issue reports
+- Remove ReadLine in list commands
+- Sum track errors in Redumper
+- Format CleanRip BCA wtih 2-byte blocks
+- Update Redumper to build 416
+- Fix trimming of header output
+- Use fake filename for Redumper DAT
+- Ensure that the full base path is being used
+- Ensure consistency in output file path checking
+- Use new output file logic in processors
+- Ensure Regex directories are unescaped
+- Add separate field for Regex; assorted cleanup
+- Reduce cleverness in output file code
+- No directory means no files
+- Update RedumpLib to 1.4.4
+- Use rolling release, not AppVeyor, in issue templates
+- Update BinaryObjectScanner to 3.1.15
+- Remove unused IndexRange library
+- Remove unnecessary System.ValueTuple usage
+- Remove old .NET version of ValueTuple where possible
+- Remove unused CompilerServices.Unsafe library
+- Simplify GetMediaType return
+- Reduce call complexity for login result
+- Use new ProtectionDictionary type
+- Replace user info func with ProcessUserInfoDelegate
+- Reduce tupling even more
+- Remove tupling from everything except CLI programs
+- Remove last instances of ValueTuple usage
+- Update BinaryObjectScanner to 3.1.16
+- Attempt to reduce nesting in GHA builds
+- Add conf to build matrix
+- Ensure debug symbols are stripped
+- Fix missed GetOutputFiles invocation
+- Reduce null use in BaseProcessor
+- Force rebuild of rolling
+
+### 3.2.2 (2024-09-24)
 
 - Clean up some Check options, add IRD option
 - Add Check flags for protection scan extras
@@ -116,7 +671,7 @@
 - Add include artifacts flag for check, sanitize options
 - Remove old --protect-file mentions (JohnVeness)
 - Update RedumpLib to 1.4.1
-- Enable loading seed JSON (Deterous)
+- Enable loading seed JSON
 
 ### 3.2.0 (2024-06-20)
 
@@ -192,7 +747,7 @@
 - Clean up usings
 - Remove automatic eject and reset options
 - Remove options from UI
-- Remove firmware output for Redumper (Deterous)
+- Remove firmware output for Redumper
 - Merge EnumConverter and EnumExtensions
 - Move event args to root of Core
 - Move processing queue to root of Core
@@ -232,7 +787,7 @@
 - Rename main application to MPF.UI
 - Fix build scripts
 - Make protection file output required
-- Standardize PS1-5 outputs and parsing (Deterous)
+- Standardize PS1-5 outputs and parsing
 - Update Redumper to build 371
 - Tools always run in separate window
 - Move ConsoleLogger to Check CLI
@@ -308,22 +863,22 @@
 ### 3.1.9 (2024-05-19)
 
 - Update Redumper to build 325
-- Fix CleanRip not pulling info (Deterous)
-- Fix XboxOne/XboxSX Filename bug (Deterous)
-- Trim PIC for XboxOne/XboxSX (Deterous)
+- Fix CleanRip not pulling info
+- Fix XboxOne/XboxSX Filename bug
+- Trim PIC for XboxOne/XboxSX
 - Get volume label from UIC outputs
 - Add site code listing to Check
 - Update RedumpLib and related
 - Update BinaryObjectScanner to 3.1.11
 - Remove now-unused Hash enum
 - Use IO implementation of IniFile
-- Add Xbox Backup Creator support to MPF.Check (Deterous)
+- Add Xbox Backup Creator support to MPF.Check
 - Update BinaryObjectScanner to 3.1.12
-- Prefer PlayStation info from Redumper logs (Deterous)
+- Prefer PlayStation info from Redumper logs
 
 ### 3.1.8 (2024-05-09)
 
-- Option for default Redumper leadin retries (Deterous)
+- Option for default Redumper leadin retries
 - Omit false positives on formatting protections
 - Critical update to BinaryObjectScanner 3.1.10
 - Add _PFI.bin support for UIC
@@ -334,9 +889,9 @@
 
 ### 3.1.6 (2024-04-27)
 
-- Fix parameter parsing for `=` symbol (Deterous)
-- Define better default categories (Deterous)
-- Custom non-redump Redumper options (Deterous)
+- Fix parameter parsing for `=` symbol
+- Define better default categories
+- Custom non-redump Redumper options
 - Update packages
 - Update packages
 
@@ -353,10 +908,10 @@
 - Fix information pulling for redumper (fuzz6001)
 - Update packages
 - Update BinaryObjectScanner to 3.1.4
-- Detect Xbox Series X discs (Deterous)
+- Detect Xbox Series X discs
 - Enable Windows targeting for test project
 - Fix test project project includes
-- Fix CleanRip hash output for Check (Deterous)
+- Fix CleanRip hash output for Check
 - Enable label-side mastering SID and toolstamp
 - Enable remaining fields for label-side information
 - Update BinaryObjectScanner to 3.1.5
@@ -373,38 +928,38 @@
 - Remove GHA pull request builds
 - Add PR check workflow
 - Don't link to AppVeyor artifacts page anymore
-- Add PS3 CFW support to MPF.Check (Deterous)
-- Hide size if value is 0 (Deterous)
-- Fix title normalization (Deterous)
+- Add PS3 CFW support to MPF.Check
+- Hide size if value is 0
+- Fix title normalization
 - Ensure no labels are empty
 - Use SabreTools.Hashing
 - Update to SabreTools.RedumpLib 1.3.5
 - Update packages to latest
-- Enable LibIRD for all .NET frameworks (Deterous)
+- Enable LibIRD for all .NET frameworks
 - Try updating PR check action
-- Fix config access persmission (Deterous)
-- Fix Check UI deadlock (Deterous)
+- Fix config access persmission
+- Fix Check UI deadlock
 - Fix formatting output formatting
-- Update LibIRD to 0.9.0 (Deterous)
+- Update LibIRD to 0.9.0
 - Update packages
-- Fix Redumper generic drive type (Deterous)
-- Add MPF version to Submission info (Deterous)
+- Fix Redumper generic drive type
+- Add MPF version to Submission info
 - Update to RedumpLib 1.3.6
 
 ### 3.1.2 (2024-02-27)
 
 - Remove debugging lines from build script
 - Port build script fixes from BOS
-- Fix double git hash version (feat. Deterous)
+- Fix double git hash version
 - Readd x86 builds by default
-- Hide unavailable dumping programs (Deterous)
+- Hide unavailable dumping programs
 - Remove DIC and Aaru bundles from CI
 - Add x86 builds to AppVeyor
 - Make AppVeyor builds framework-dependent
 - Fix misattributed artifact
 - Update README with current build instructions
-- Opt-in automatic IRD creation after PS3 dump (Deterous)
-- Add CI via Github Workflows (Deterous)
+- Opt-in automatic IRD creation after PS3 dump
+- Add CI via Github Workflows
 - Reorganize solution items
 - Split CI workflow files
 - Add GHA CI status badges
@@ -434,19 +989,19 @@
 - Show hashes in readonly data
 - Update to BinaryObjectScanner 3.1.0
 - Add Mattel HyperScan detection
-- Pull PS3 Disc Key from redump (Deterous)
+- Pull PS3 Disc Key from redump
 
 ### 3.1.1 (2024-02-20)
 
 - Remove .NET 6 from auto-builds
 - Make Redumper the default for new users
-- Fix DIC log parsing for SS version (Deterous)
+- Fix DIC log parsing for SS version
 - Write outputs with UTF-8
 - Add funworld Photo Play detection
 - Fix Aaru drive parameter generation
 - Limit DVD protection outputs
-- Add a GUI for PS3 IRD Creation (Deterous)
-- Update LibIRD, disable UI elements when creating IRD (Deterous)
+- Add a GUI for PS3 IRD Creation
+- Update LibIRD, disable UI elements when creating IRD
 
 ### 3.1.0 (2024-02-06)
 
@@ -454,33 +1009,33 @@
 - Update Redumper to build 294
 - Fix commented out code
 - Make missing hash data clearer
-- Get BD PIC Identifier for redumper (Deterous)
-- Support redumper skeleton and hash files (Deterous)
+- Get BD PIC Identifier for redumper
+- Support redumper skeleton and hash files
 - Support ringcode and PIC for triple/quad-layer (fuzz6001)
-- Cleanup !protectionInfo.txt (Deterous)
-- Update Redumper to build 311 (Deterous)
-- Use PSX/PS2 serial as filename when Volume Label not present (Deterous)
-- Allow variables in output path (Deterous)
-- Check for presence of complete dump from other programs (Deterous)
-- Retrieve volume label from logs (Deterous)
+- Cleanup !protectionInfo.txt
+- Update Redumper to build 311
+- Use PSX/PS2 serial as filename when Volume Label not present
+- Allow variables in output path
+- Check for presence of complete dump from other programs
+- Retrieve volume label from logs
 - Correct missing space in PVD (fuzz6001)
-- Prevent crashing on invalid parameters (Deterous)
-- Detect CDTV discs (Deterous)
-- Differentiate CD32 from CDTV (Deterous)
-- Normalise Disc Titles in Submission Info (Deterous)
+- Prevent crashing on invalid parameters
+- Detect CDTV discs
+- Differentiate CD32 from CDTV
+- Normalise Disc Titles in Submission Info
 - Skip warning line in Redumper log
-- Add a GUI for MPF.Check (Deterous)
+- Add a GUI for MPF.Check
 - Fix information pulling for CleanRip and UIC
 - Add UMD handling for the disc info window
 - Detect Photo CD
-- Parse PSX/PS2/KP2 exe date from logs (Deterous)
-- Exclude extra tracks when finding disc matches (Deterous)
-- Verbose Redumper log by default (Deterous)
+- Parse PSX/PS2/KP2 exe date from logs
+- Exclude extra tracks when finding disc matches
+- Verbose Redumper log by default
 - Retrieve serial from Cleanrip
 - Fix build from rushed code
 - Remove `-disc2` from Cleanrip serial
 - Enable Windows builds on Linux and Mac
-- Fix compiler warning (Deterous)
+- Fix compiler warning
 
 ### 3.0.3 (2023-12-04)
 
@@ -568,15 +1123,15 @@
 
 ### 2.7.5 (2023-11-06)
 
-- Remove psxt001z Pkg Ref in MPF.Test (Deterous)
+- Remove psxt001z Pkg Ref in MPF.Test
 - Update Redumper to build 247
-- Focus main window after child window closes (Deterous)
+- Focus main window after child window closes
 - Try to get PS3 data from SFB
 - Fix PS3 version finding
-- Pull PS3 Firmware Version (Deterous)
+- Pull PS3 Firmware Version
 - Fix default layerbreak output
-- Enable browsing for Redumper path (Deterous)
-- Update to MMI 3.0.0 (Deterous)
+- Enable browsing for Redumper path
+- Update to MMI 3.0.0
 
 ### 2.7.4 (2023-10-31)
 
@@ -597,7 +1152,7 @@
 - Compile most regex statements
 - Handle a couple of messages
 - Remove .manufacturer for Bluray
-- Fix typo that disables DIC during media check (Deterous)
+- Fix typo that disables DIC during media check
 - Fix build
 - Remove duplicate check
 - Add PIC output for Redumper
@@ -626,7 +1181,7 @@
 - Add filename suffix setting (nw)
 - Wire through filename suffix
 - Expose suffix setting
-- Set UDF CD threshold at 800MB (Deterous)
+- Set UDF CD threshold at 800MB
 - Update package versions
 - Attempt to parse out PS5 params.json
 - Fix CRC32 hashing
@@ -635,7 +1190,7 @@
 - Update to MMI 3.0.0-preview.4
 - Fix two small nullability issues
 - Use Array.Empty in hasher
-- Always use relative path internally (Deterous)
+- Always use relative path internally
 
 ### 2.7.2 (2023-10-17)
 
@@ -643,9 +1198,9 @@
 - Cleanup and gated code
 - Gate some switch expressions
 - Suppress some unnecessary messages
-- Disable dumping button when Redumper selected with unsupported media type (Deterous)
-- Improve check for which program supports which media (Deterous)
-- Remove code for getting Universal Hash from DIC logs (Deterous)
+- Disable dumping button when Redumper selected with unsupported media type
+- Improve check for which program supports which media
+- Remove code for getting Universal Hash from DIC logs
 - Fix Redumper retry count not showing
 - Enable parameters checkbox by default
 - Update Redumper to build 230
@@ -665,7 +1220,7 @@
 - Unify handling of enable/disable events
 - Enable nullability in Check
 - Remove all but .NET 6 for AppVeyor packaging
-- Place message boxes at center of main window (Deterous)
+- Place message boxes at center of main window
 - Enable nullability in MPF
 - Enable nullability in MPF.UI.Core
 - Enable nullability in MPF.Test
@@ -701,7 +1256,7 @@
 - Be smarter about media type based on system
 - Consolidate into MPF.Core
 - Fix failing tests
-- Remove debug symbols in release builds (Deterous)
+- Remove debug symbols in release builds
 - Allow nullability for modern .NET
 - Fix failing tests
 - Remove unnecessary include
@@ -709,7 +1264,7 @@
 - Move LogLevel enumeration
 - Split logging code a bit more
 - Split info window code a bit more
-- Clarify build instructions in README (Deterous)
+- Clarify build instructions in README
 - Split options window code a bit more
 - Use binding for more disc info textboxes
 - Handle Redump password changing better
@@ -735,7 +1290,7 @@
 - Fix media type ordering
 - Fix dumping button not enabling
 - Recentralize some Check functionality
-- Fix media combobox not updating (Deterous)
+- Fix media combobox not updating
 
 ### 2.6.6 (2023-10-04)
 
@@ -784,7 +1339,7 @@
 - Handle extension changing only
 - Swap order of operations for changing program
 - Fix dumping path in DD
-- Fix PlayStation serial code region parsing (Deterous)
+- Fix PlayStation serial code region parsing
 - Retrofit README
 - Migrate to Nuget package for Redump
 - Remove dd for Windows

MPF.CLI/Features/BaseFeature.cs

@@ -0,0 +1,276 @@
+
+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;
+using LogCompression = MPF.Processors.LogCompression;
+
+namespace MPF.CLI.Features
+{
+    internal abstract class BaseFeature : SabreTools.CommandLine.Feature
+    {
+        #region Properties
+
+        /// <summary>
+        /// User-defined options
+        /// </summary>
+        public Options Options { get; protected set; }
+
+        /// <summary>
+        /// Currently-selected system
+        /// </summary>
+        public RedumpSystem? System { get; protected set; }
+
+        /// <summary>
+        /// Media type to dump
+        /// </summary>
+        /// <remarks>Required for DIC and if custom parameters not set</remarks>
+        public MediaType? MediaType { get; protected set; }
+
+        /// <summary>
+        /// Path to the device to dump
+        /// </summary>
+        /// <remarks>Required if custom parameters are not set</remarks>
+        public string? DevicePath { get; protected set; }
+
+        /// <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; protected set; }
+
+        /// <summary>
+        /// Path to the output file
+        /// </summary>
+        /// <remarks>Required if custom parameters are not set</remarks>
+        public string? FilePath { get; protected set; }
+
+        /// <summary>
+        /// Override drive speed
+        /// </summary>
+        public int? DriveSpeed { get; protected set; }
+
+        /// <summary>
+        /// Custom parameters for dumping
+        /// </summary>
+        public string? CustomParams { get; protected set; }
+
+        #endregion
+
+        protected BaseFeature(string name, string[] flags, string description, string? detailed = null)
+            : base(name, flags, description, detailed)
+        {
+            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,
+                LogCompression = LogCompression.DeflateMaximum,
+                DeleteUnnecessaryFiles = false,
+                CreateIRDAfterDumping = false,
+
+                // Protection Scanning Options
+                ScanArchivesForProtection = true,
+                IncludeDebugProtectionInformation = false,
+                HideDriveLetters = false,
+
+                // Redump Login Information
+                RetrieveMatchInformation = true,
+                RedumpUsername = null,
+                RedumpPassword = null,
+            };
+        }
+
+        /// <inheritdoc/>
+        public override bool Execute()
+        {
+            // 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);
+            }
+
+            // Validate the internal program
+            switch (Options.InternalProgram)
+            {
+                case InternalProgram.Aaru:
+                    if (!File.Exists(Options.AaruPath))
+                    {
+                        Console.Error.WriteLine("A path needs to be supplied in config.json for Aaru, exiting...");
+                        return false;
+                    }
+                    break;
+
+                case InternalProgram.DiscImageCreator:
+                    if (!File.Exists(Options.DiscImageCreatorPath))
+                    {
+                        Console.Error.WriteLine("A path needs to be supplied in config.json for DIC, exiting...");
+                        return false;
+                    }
+                    break;
+
+                case InternalProgram.Redumper:
+                    if (!File.Exists(Options.RedumperPath))
+                    {
+                        Console.Error.WriteLine("A path needs to be supplied in config.json for Redumper, exiting...");
+                        return false;
+                    }
+                    break;
+
+                default:
+                    Console.Error.WriteLine($"{Options.InternalProgram} is not a supported dumping program, exiting...");
+                    break;
+            }
+
+            // Ensure we have the values we need
+            if (CustomParams == null && DevicePath == null)
+            {
+                Console.Error.WriteLine("Either custom parameters or a device path need to be provided, exiting...");
+                return false;
+            }
+            if (Options.InternalProgram == InternalProgram.DiscImageCreator
+                && CustomParams == null
+                && (MediaType == null || MediaType == SabreTools.RedumpLib.Data.MediaType.NONE))
+            {
+                Console.Error.WriteLine("Media type is required for DiscImageCreator, exiting...");
+                return false;
+            }
+
+            // Normalize the file path
+            if (DevicePath != null && FilePath == null)
+            {
+                FilePath = $"track_{DateTime.Now:yyyyMMdd-HHmm}.bin";
+                if (Options.DefaultOutputPath != null)
+                    FilePath = Path.Combine(Options.DefaultOutputPath, FilePath);
+            }
+            if (FilePath != null)
+                FilePath = FrontendTool.NormalizeOutputPaths(FilePath, getFullPath: true);
+
+            // Get the speed from the options
+            int speed = DriveSpeed ?? FrontendTool.GetDefaultSpeedForMediaType(MediaType, Options);
+
+            // Populate an environment
+            var drive = Drive.Create(null, DevicePath ?? string.Empty);
+            var env = new DumpEnvironment(Options,
+                FilePath,
+                drive,
+                System,
+                Options.InternalProgram);
+            env.SetExecutionContext(MediaType, null);
+            env.SetProcessor();
+
+            // Process the parameters
+            string? paramStr = CustomParams ?? env.GetFullParameters(MediaType, speed);
+            if (string.IsNullOrEmpty(paramStr))
+            {
+                Console.Error.WriteLine("No valid environment could be created, exiting...");
+                return false;
+            }
+
+            env.SetExecutionContext(MediaType, paramStr);
+
+            // Invoke the dumping program
+            Console.WriteLine($"Invoking {Options.InternalProgram} using '{paramStr}'");
+            var dumpResult = env.Run(MediaType).GetAwaiter().GetResult();
+            Console.WriteLine(dumpResult.Message);
+            if (!dumpResult)
+                return false;
+
+            // If it was not a dumping command
+            if (!env.IsDumpingCommand())
+            {
+                Console.Error.WriteLine();
+                Console.WriteLine("Execution not recognized as dumping command, skipping processing...");
+                return true;
+            }
+
+            // If we have a mounted path, replace the environment
+            if (MountedPath != null && Directory.Exists(MountedPath))
+            {
+                drive = Drive.Create(null, MountedPath);
+                env = new DumpEnvironment(Options,
+                    FilePath,
+                    drive,
+                    System,
+                    internalProgram: null);
+                env.SetExecutionContext(MediaType, null);
+                env.SetProcessor();
+            }
+
+            // Finally, attempt to do the output dance
+            var verifyResult = env.VerifyAndSaveDumpOutput()
+                .ConfigureAwait(false).GetAwaiter().GetResult();
+            Console.WriteLine(verifyResult.Message);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Display help for MPF.CLI
+        /// </summary>
+        /// <param name="error">Error string to prefix the help text with</param>
+        public static void DisplayHelp()
+        {
+            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("lo, listconfig          List current configuration values");
+            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 (Recommended, uses defaults otherwise)");
+            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, a drive path is 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();
+        }
+    }
+}

MPF.CLI/Features/InteractiveFeature.cs

@@ -0,0 +1,190 @@
+
+using System;
+using System.IO;
+using MPF.Frontend;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.CLI.Features
+{
+    internal sealed class InteractiveFeature : BaseFeature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "interactive";
+
+        private static readonly string[] _flags = ["i", "interactive"];
+
+        private const string _description = "Enable interactive mode";
+
+        #endregion
+
+        public InteractiveFeature()
+            : base(DisplayName, _flags, _description)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override bool ProcessArgs(string[] args, int index)
+        {
+            // Cache all args as inputs
+            for (int i = 1; i < args.Length; i++)
+            {
+                Inputs.Add(args[i]);
+            }
+
+            // Read the options from config, if possible
+            Options = OptionsLoader.LoadFromConfig();
+
+            // Create return values
+            MediaType = SabreTools.RedumpLib.Data.MediaType.NONE;
+            FilePath = Path.Combine(Options.DefaultOutputPath ?? "ISO", $"track_{DateTime.Now:yyyyMMdd-HHmm}.bin");
+            System = Options.DefaultSystem;
+
+            // Create state values
+            string? result;
+
+        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 '{MediaType}')");
+            Console.WriteLine($"4) Set device path (Currently '{DevicePath}')");
+            Console.WriteLine($"5) Set mounted path (Currently '{MountedPath}')");
+            Console.WriteLine($"6) Set file path (Currently '{FilePath}')");
+            Console.WriteLine($"7) Set override speed (Currently '{DriveSpeed}')");
+            Console.WriteLine($"8) Set custom parameters (Currently '{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("For possible inputs, use the List Systems commandline option");
+            Console.WriteLine();
+            Console.WriteLine("Input the system and press Enter:");
+            Console.Write("> ");
+            result = Console.ReadLine();
+            System = result.ToRedumpSystem();
+            goto root;
+
+        dumpingProgram:
+            Console.WriteLine();
+            Console.WriteLine("Options:");
+            Console.WriteLine($"{InternalProgram.Redumper.ToString().ToLowerInvariant(),-15} => {InternalProgram.Redumper.LongName()}");
+            Console.WriteLine($"{InternalProgram.DiscImageCreator.ToString().ToLowerInvariant(),-15} => {InternalProgram.DiscImageCreator.LongName()}");
+            Console.WriteLine($"{InternalProgram.Aaru.ToString().ToLowerInvariant(),-15} => {InternalProgram.Aaru.LongName()}");
+            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("For possible inputs, use the List Media commandline option");
+            Console.WriteLine();
+            Console.WriteLine("Input the media type and press Enter:");
+            Console.Write("> ");
+            result = Console.ReadLine();
+            MediaType = OptionsLoader.ToMediaType(result);
+            goto root;
+
+        devicePath:
+            Console.WriteLine();
+            Console.WriteLine("Input the device path and press Enter:");
+            Console.Write("> ");
+            DevicePath = Console.ReadLine();
+            goto root;
+
+        mountedPath:
+            Console.WriteLine();
+            Console.WriteLine("Input the mounted path and press Enter:");
+            Console.Write("> ");
+            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!);
+
+            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;
+
+            DriveSpeed = speed;
+            goto root;
+
+        customParams:
+            Console.WriteLine();
+            Console.WriteLine("Input the custom parameters and press Enter:");
+            Console.Write("> ");
+            CustomParams = Console.ReadLine();
+            goto root;
+
+        exit:
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => true;
+    }
+}

MPF.CLI/Features/MainFeature.cs

@@ -0,0 +1,115 @@
+
+using MPF.Frontend;
+using MPF.Frontend.Tools;
+using SabreTools.CommandLine.Inputs;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.CLI.Features
+{
+    internal sealed class MainFeature : BaseFeature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "main";
+
+        /// <remarks>Flags are unused</remarks>
+        private static readonly string[] _flags = [];
+
+        /// <remarks>Description is unused</remarks>
+        private const string _description = "";
+
+        #endregion
+
+        #region Inputs
+
+        private const string _customName = "custom";
+        internal readonly StringInput CustomInput = new(_customName, ["-c", "--custom"], "Custom parameters to use");
+
+        private const string _deviceName = "device";
+        internal readonly StringInput DeviceInput = new(_deviceName, ["-d", "--device"], "Physical drive path (Required if no custom parameters set)");
+
+        private const string _fileName = "file";
+        internal readonly StringInput FileInput = new(_fileName, ["-f", "--file"], "Output file path (Required if no custom parameters set)");
+
+        private const string _mediaTypeName = "media-type";
+        internal readonly StringInput MediaTypeInput = new(_mediaTypeName, ["-t", "--mediatype"], "Set media type for dumping (Required for DIC)");
+
+        private const string _mountedName = "mounted";
+        internal readonly StringInput MountedInput = new(_mountedName, ["-m", "--mounted"], "Mounted filesystem path for additional checks");
+
+        private const string _speedName = "speed";
+        internal readonly Int32Input SpeedInput = new(_speedName, ["-s", "--speed"], "Override default dumping speed");
+
+        private const string _useName = "use";
+        internal readonly StringInput UseInput = new(_useName, ["-u", "--use"], "Override configured dumping program name");
+
+        #endregion
+
+        public MainFeature()
+            : base(DisplayName, _flags, _description)
+        {
+            Add(UseInput);
+            Add(MediaTypeInput);
+            Add(DeviceInput);
+            Add(MountedInput);
+            Add(FileInput);
+            Add(SpeedInput);
+            Add(CustomInput);
+        }
+
+        /// <inheritdoc/>
+        public override bool ProcessArgs(string[] args, int index)
+        {
+            // If we have no arguments, just return
+            if (args == null || args.Length == 0)
+                return true;
+
+            // Read the options from config, if possible
+            Options = OptionsLoader.LoadFromConfig();
+
+            // The first argument is the system type
+            System = args[0].Trim('"').ToRedumpSystem();
+
+            // Loop through the arguments and parse out values
+            for (index = 1; index < args.Length; index++)
+            {
+                // Use specific program
+                if (UseInput.ProcessInput(args, ref index))
+                    Options.InternalProgram = UseInput.Value.ToInternalProgram();
+
+                // Set a media type
+                else if (MediaTypeInput.ProcessInput(args, ref index))
+                    MediaType = OptionsLoader.ToMediaType(MediaTypeInput.Value?.Trim('"'));
+
+                // Use a device path
+                else if (DeviceInput.ProcessInput(args, ref index))
+                    DevicePath = DeviceInput.Value;
+
+                // Use a mounted path for physical checks
+                else if (MountedInput.ProcessInput(args, ref index))
+                    MountedPath = MountedInput.Value;
+
+                // Use a file path
+                else if (FileInput.ProcessInput(args, ref index))
+                    FilePath = FileInput.Value;
+
+                // Set an override speed
+                else if (SpeedInput.ProcessInput(args, ref index))
+                    DriveSpeed = SpeedInput.Value;
+
+                // Use a custom parameters
+                else if (CustomInput.ProcessInput(args, ref index))
+                    CustomParams = CustomInput.Value;
+
+                // Default, add to inputs
+                else
+                    Inputs.Add(args[index]);
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => true;
+    }
+}

MPF.CLI/MPF.CLI.csproj

@@ -1,22 +1,24 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<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</TargetFrameworks>
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0;net10.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.2.2</VersionPrefix>
+        <VersionPrefix>3.6.0</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-2024</Copyright>
+        <Copyright>Copyright (c) Matt Nadareski 2019-2025</Copyright>
         <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
         <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
@@ -29,33 +31,20 @@
     <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`))">
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`)) OR $(TargetFramework.StartsWith(`net9`)) OR $(TargetFramework.StartsWith(`net10`))">
         <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</TargetFrameworks>
+        <TargetFrameworks>net6.0;net7.0;net8.0;net9.0;net10.0</TargetFrameworks>
     </PropertyGroup>
 
-    <!-- Support for old .NET versions -->
-    <ItemGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net40`))">
-        <PackageReference Include="MinAsyncBridge" Version="0.12.4" />
-        <PackageReference Include="MinTasksExtensionsBridge" Version="0.3.4" />
-        <PackageReference Include="MinThreadingBridge" Version="0.11.4" />
-    </ItemGroup>
-
     <ItemGroup>
         <ProjectReference Include="..\MPF.Frontend\MPF.Frontend.csproj" />
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.13" GeneratePathProperty="true">
-            <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
-        </PackageReference>
-        <PackageReference Include="SabreTools.RedumpLib" Version="1.4.1" />
-    </ItemGroup>
-
-    <ItemGroup>
-        <Content Include="$(PkgBinaryObjectScanner)\content\**" PackagePath="contentFiles\any\any;content" CopyToOutputDirectory="Always" PackageCopyToOutput="true" />
+        <PackageReference Include="SabreTools.CommandLine" Version="[1.4.0]" />
+        <PackageReference Include="SabreTools.RedumpLib" Version="[1.9.0]" />
     </ItemGroup>
 
 </Project>

MPF.CLI/Program.cs

@@ -1,13 +1,13 @@
 using System;
-using System.IO;
+using System.Collections.Generic;
 #if NET40
 using System.Threading.Tasks;
 #endif
-using BinaryObjectScanner;
-using MPF.Frontend;
+using MPF.CLI.Features;
+using MPF.Frontend.Features;
 using MPF.Frontend.Tools;
-using SabreTools.RedumpLib.Data;
-using SabreTools.RedumpLib.Web;
+using SabreTools.CommandLine;
+using SabreTools.CommandLine.Features;
 
 namespace MPF.CLI
 {
@@ -19,321 +19,123 @@ namespace MPF.CLI
             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, saveDefault: true);
+                OptionsLoader.SaveToConfig(options);
+
+                // Display non-error message
+                Console.WriteLine("First-run detected! Please verify the generated config.json and run again.");
+                return;
             }
 
+            // Create the command set
+            var mainFeature = new MainFeature();
+            var commandSet = CreateCommands(mainFeature);
+
+            // If we have no args, show the help and quit
+            if (args == null || args.Length == 0)
+            {
+                BaseFeature.DisplayHelp();
+                return;
+            }
+
+            // Get the first argument as a feature flag
+            string featureName = args[0];
+
             // Try processing the standalone arguments
-            bool? standaloneProcessed = OptionsLoader.ProcessStandaloneArguments(args);
-            if (standaloneProcessed != false)
+            var topLevel = commandSet.GetTopLevel(featureName);
+            switch (topLevel)
             {
-                if (standaloneProcessed == null)
-                    DisplayHelp();
-                return;
-            }
+                // Standalone Options
+                case Help: BaseFeature.DisplayHelp(); return;
+                case VersionFeature version: version.Execute(); return;
+                case ListCodesFeature lc: lc.Execute(); return;
+                case ListConfigFeature lc: lc.Execute(); return;
+                case ListMediaTypesFeature lm: lm.Execute(); return;
+                case ListProgramsFeature lp: lp.Execute(); return;
+                case ListSystemsFeature ls: ls.Execute(); return;
 
-            // Try processing the common arguments
-            (bool success, MediaType mediaType, RedumpSystem? knownSystem, var error) = OptionsLoader.ProcessCommonArguments(args);
-            if (!success)
-            {
-                DisplayHelp(error);
-                return;
-            }
-
-            // Validate the supplied credentials
-            (bool? _, string? message) = RedumpClient.ValidateCredentials(options.RedumpUsername ?? string.Empty, options.RedumpPassword ?? string.Empty).GetAwaiter().GetResult();
-            if (!string.IsNullOrEmpty(message))
-                Console.WriteLine(message);
-
-            // Process any custom parameters
-            (CommandOptions opts, int startIndex) = LoadFromArguments(args, options, startIndex: 2);
-            
-            // Validate the internal program
-            switch (options.InternalProgram)
-            {
-                case InternalProgram.Aaru:
-                    if (!File.Exists(options.AaruPath))
+                // Interactive Mode
+                case InteractiveFeature interactive:
+                    if (!interactive.ProcessArgs(args, 0))
                     {
-                        DisplayHelp("A path needs to be supplied for Aaru, exiting...");
+                        BaseFeature.DisplayHelp();
                         return;
                     }
-                    break;
-
-                case InternalProgram.DiscImageCreator:
-                    if (!File.Exists(options.DiscImageCreatorPath))
+                    if (!interactive.Execute())
                     {
-                        DisplayHelp("A path needs to be supplied for DIC, exiting...");
-                        return;
-                    }
-                    break;
-
-                case InternalProgram.Redumper:
-                    if (!File.Exists(options.RedumperPath))
-                    {
-                        DisplayHelp("A path needs to be supplied for Redumper, exiting...");
+                        BaseFeature.DisplayHelp();
                         return;
                     }
+
                     break;
 
+                // Default Behavior
                 default:
-                    DisplayHelp($"{options.InternalProgram} is not a supported dumping program, exiting...");
+                    if (!mainFeature.ProcessArgs(args, 0))
+                    {
+                        BaseFeature.DisplayHelp();
+                        return;
+                    }
+                    if (!mainFeature.Execute())
+                    {
+                        BaseFeature.DisplayHelp();
+                        return;
+                    }
+
                     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;
-            }
-
-            // Get the speed from the options
-            int speed = opts.DriveSpeed ?? FrontendTool.GetDefaultSpeedForMediaType(mediaType, options);
-
-            // Populate an environment
-            var drive = Drive.Create(null, opts.DevicePath ?? string.Empty);
-            var env = new DumpEnvironment(options,
-                opts.FilePath,
-                drive,
-                knownSystem,
-                mediaType,
-                options.InternalProgram,
-                parameters: null);
-
-            // Process the parameters
-            string? paramStr = opts.CustomParams ?? env.GetFullParameters(speed);
-            if (string.IsNullOrEmpty(paramStr))
-            {
-                DisplayHelp("No valid environment could be created, exiting...");
-                return;
-            }
-            env.SetExecutionContext(paramStr);
-
-            // Make new Progress objects
-            var resultProgress = new Progress<ResultEventArgs>();
-            resultProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
-            var protectionProgress = new Progress<ProtectionProgress>();
-            protectionProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
-
-            // Invoke the dumping program
-            Console.WriteLine($"Invoking {options.InternalProgram} using '{paramStr}'");
-            var dumpResult = env.Run(resultProgress).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,
-                    mediaType,
-                    internalProgram: null,
-                    parameters: null);
-            }
-
-            // Finally, attempt to do the output dance
-#if NET40
-            var verifyTask = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress);
-            verifyTask.Wait();
-            var verifyResult = verifyTask.Result;
-#else
-            var verifyResult = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress).ConfigureAwait(false).GetAwaiter().GetResult();
-#endif
-            Console.WriteLine(verifyResult.Message);
         }
 
         /// <summary>
-        /// Display help for MPF.CLI
+        /// Create the command set for the program
         /// </summary>
-        /// <param name="error">Error string to prefix the help text with</param>
-        private static void DisplayHelp(string? error = null)
+        private static CommandSet CreateCommands(MainFeature mainFeature)
         {
-            if (error != null)
-                Console.WriteLine(error);
+            List<string> header = [
+                "MPF.CLI [standalone|system] [options] <path> ...",
+                string.Empty,
+            ];
 
-            Console.WriteLine("Usage:");
-            Console.WriteLine("MPF.CLI <mediatype> <system> [options]");
-            Console.WriteLine();
-            Console.WriteLine("Standalone Options:");
-            Console.WriteLine("-h, -?                  Show this help text");
-            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();
+            List<string> footer = [
+                string.Empty,
+                "Dumping program paths and other settings can be found in the config.json file",
+                "generated next to the program by default. Ensure that all settings are to user",
+                "preference before running MPF.CLI.",
+                string.Empty,
 
-            Console.WriteLine("CLI Options:");
-            Console.WriteLine("-u, --use <program>            Override default dumping program");
-            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();
+                "Custom dumping parameters, if used, will fully replace the default parameters.",
+                "All dumping parameters need to be supplied if doing this.",
+                "Otherwise, both a drive path and output file path are required.",
+                string.Empty,
 
-            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();
+                "Mounted filesystem path is only recommended on OSes that require block",
+                "device dumping, usually Linux and macOS.",
+                string.Empty,
+            ];
 
-            Console.WriteLine("Mounted filesystem path is only recommended on OSes that require block");
-            Console.WriteLine("device dumping, usually Linux and macOS.");
-            Console.WriteLine();
-        }
+            var commandSet = new CommandSet(header, footer);
 
-        /// <summary>
-        /// Load the current set of options from application arguments
-        /// </summary>
-        private static (CommandOptions, int) LoadFromArguments(string[] args, Frontend.Options options, int startIndex = 0)
-        {
-            // Create return values
-            var opts = new CommandOptions();
+            // Standalone Options
+            commandSet.Add(new Help());
+            commandSet.Add(new VersionFeature());
+            commandSet.Add(new ListCodesFeature());
+            commandSet.Add(new ListConfigFeature());
+            commandSet.Add(new ListMediaTypesFeature());
+            commandSet.Add(new ListSystemsFeature());
+            commandSet.Add(new ListProgramsFeature());
+            commandSet.Add(new InteractiveFeature());
 
-            // If we have no arguments, just return
-            if (args == null || args.Length == 0)
-                return (opts, 0);
+            // CLI Options
+            commandSet.Add(mainFeature.UseInput);
+            commandSet.Add(mainFeature.MediaTypeInput);
+            commandSet.Add(mainFeature.DeviceInput);
+            commandSet.Add(mainFeature.MountedInput);
+            commandSet.Add(mainFeature.FileInput);
+            commandSet.Add(mainFeature.SpeedInput);
+            commandSet.Add(mainFeature.CustomInput);
 
-            // If we have an invalid start index, just return
-            if (startIndex < 0 || startIndex >= args.Length)
-                return (opts, startIndex);
-
-            // 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 = Frontend.Options.ToInternalProgram(internalProgram);
-                }
-                else if (args[startIndex] == "-u" || args[startIndex] == "--use")
-                {
-                    string internalProgram = args[startIndex + 1];
-                    options.InternalProgram = Frontend.Options.ToInternalProgram(internalProgram);
-                    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, startIndex);
-        }
-
-        /// <summary>
-        /// Represents commandline options
-        /// </summary>
-        private class CommandOptions
-        {
-            /// <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;
+            return commandSet;
         }
     }
 }

MPF.Check/App.config

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-    <startup> 
-        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.6.2"/>
-    </startup>
-</configuration>

MPF.Check/ConsoleLogger.cs

@@ -1,25 +0,0 @@
-using System;
-using BinaryObjectScanner;
-using MPF.Frontend;
-
-namespace MPF.Check
-{
-    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.Check/Features/BaseFeature.cs

@@ -0,0 +1,176 @@
+
+using System;
+using System.IO;
+#if NET40
+using System.Threading.Tasks;
+#endif
+using MPF.Frontend;
+using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Web;
+using LogCompression = MPF.Processors.LogCompression;
+
+namespace MPF.Check.Features
+{
+    internal abstract class BaseFeature : SabreTools.CommandLine.Feature
+    {
+        #region Properties
+
+        /// <summary>
+        /// User-defined options
+        /// </summary>
+        public Options Options { get; protected set; }
+
+        /// <summary>
+        /// Currently-selected system
+        /// </summary>
+        public RedumpSystem? System { get; protected set; }
+
+        /// <summary>
+        /// Seed submission info from an input file
+        /// </summary>
+        public SubmissionInfo? Seed { get; protected set; }
+
+        /// <summary>
+        /// Path to the device to scan
+        /// </summary>
+        public string? DevicePath { get; protected set; }
+
+        #endregion
+
+        protected BaseFeature(string name, string[] flags, string description, string? detailed = null)
+            : base(name, flags, description, detailed)
+        {
+            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,
+                LogCompression = LogCompression.DeflateMaximum,
+                DeleteUnnecessaryFiles = false,
+                CreateIRDAfterDumping = false,
+
+                // Protection Scanning Options
+                ScanArchivesForProtection = true,
+                IncludeDebugProtectionInformation = false,
+                HideDriveLetters = false,
+
+                // Redump Login Information
+                RetrieveMatchInformation = true,
+                RedumpUsername = null,
+                RedumpPassword = null,
+            };
+        }
+
+        /// <inheritdoc/>
+        public override bool Execute()
+        {
+            if (Options.InternalProgram == InternalProgram.NONE)
+            {
+                Console.Error.WriteLine("A program name needs to be provided");
+                return false;
+            }
+
+            // 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 = 0; i < Inputs.Count; i++)
+            {
+                // Get the full file path
+                string filepath = Path.GetFullPath(Inputs[i].Trim('"'));
+
+                // Now populate an environment
+                Drive? drive = null;
+                if (!string.IsNullOrEmpty(DevicePath))
+                    drive = Drive.Create(null, DevicePath!);
+
+                var env = new DumpEnvironment(Options,
+                    filepath,
+                    drive,
+                    System,
+                    internalProgram: null);
+                env.SetProcessor();
+
+                // Finally, attempt to do the output dance
+                var result = env.VerifyAndSaveDumpOutput(seedInfo: Seed)
+                    .ConfigureAwait(false).GetAwaiter().GetResult();
+                Console.WriteLine(result.Message);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Display help for MPF.Check
+        /// </summary>
+        /// <param name="error">Error string to prefix the help text with</param>
+        public static void DisplayHelp()
+        {
+            Console.WriteLine("Usage:");
+            Console.WriteLine("MPF.Check <system> [options] </path/to/output.cue|iso|_logs.zip> ...");
+            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("lo, listconfig          List current configuration values");
+            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) [WILL BE REMOVED]");
+            Console.WriteLine("-U, --username <user>          Redump username (incompatible with --no-retrieve)");
+            Console.WriteLine("-P, --password <pw>            Redump password (incompatible with --no-retrieve)");
+            Console.WriteLine("    --pull-all                 Pull all information from Redump (requires --username and --password)");
+            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("    --log-compression          Set the log compression type (requires compression enabled)");
+            Console.WriteLine("-d, --delete                   Enable unnecessary file deletion");
+            Console.WriteLine();
+            Console.WriteLine("WARNING: If using a configuration file alongside any of the above options");
+            Console.WriteLine("then flag options will act as toggles instead of always enabling.");
+            Console.WriteLine("For example, if log compression is enabled in your configuration file, then");
+            Console.WriteLine("providing the --zip option would disable compression.");
+            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();
+        }
+    }
+}

MPF.Check/Features/InteractiveFeature.cs

@@ -0,0 +1,288 @@
+
+using System;
+using MPF.Frontend;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+using LogCompression = MPF.Processors.LogCompression;
+
+namespace MPF.Check.Features
+{
+    internal sealed class InteractiveFeature : BaseFeature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "interactive";
+
+        private static readonly string[] _flags = ["i", "interactive"];
+
+        private const string _description = "Enable interactive mode";
+
+        #endregion
+
+        public InteractiveFeature()
+            : base(DisplayName, _flags, _description)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override bool ProcessArgs(string[] args, int index)
+        {
+            // Cache all args as inputs
+            for (int i = 1; i < args.Length; i++)
+            {
+                Inputs.Add(args[i]);
+            }
+
+            // Read the options from config, if possible
+            Options = OptionsLoader.LoadFromConfig();
+            if (Options.FirstRun)
+            {
+                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,
+                    LogCompression = LogCompression.DeflateMaximum,
+                    DeleteUnnecessaryFiles = false,
+                    CreateIRDAfterDumping = false,
+
+                    // Protection Scanning Options
+                    ScanArchivesForProtection = true,
+                    IncludeDebugProtectionInformation = false,
+                    HideDriveLetters = false,
+
+                    // Redump Login Information
+                    RetrieveMatchInformation = true,
+                    RedumpUsername = null,
+                    RedumpPassword = null,
+                };
+            }
+
+            // Create return values
+            System = null;
+
+            // These values require multiple parts to be active
+            bool scan = false,
+                enableArchives = true,
+                enableDebug = false,
+                hideDriveLetters = false;
+
+            // Create state values
+            string? result;
+
+        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 '{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 '{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) Log compression (Currently '{Options.LogCompression.LongName()}')");
+            Console.WriteLine($"J) 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":
+                    goto logCompression;
+                case "j":
+                case "J":
+                    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("For possible inputs, use the List Systems commandline option");
+            Console.WriteLine();
+            Console.WriteLine("Input the system and press Enter:");
+            Console.Write("> ");
+            result = Console.ReadLine();
+            System = result.ToRedumpSystem();
+            goto root;
+
+        dumpingProgram:
+            Console.WriteLine();
+            Console.WriteLine("Options:");
+            foreach (var program in (InternalProgram[])Enum.GetValues(typeof(InternalProgram)))
+            {
+                // Skip the placeholder values
+                if (program == InternalProgram.NONE)
+                    continue;
+
+                Console.WriteLine($"{program.ToString().ToLowerInvariant(),-15} => {program.LongName()}");
+            }
+
+            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();
+            Seed = Builder.CreateFromFile(result);
+            goto root;
+
+        redumpCredentials:
+            Console.WriteLine();
+            Console.WriteLine("Enter your Redump username and press Enter:");
+            Console.Write("> ");
+            Options.RedumpUsername = Console.ReadLine();
+
+            Console.WriteLine("Enter your Redump 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("> ");
+            DevicePath = Console.ReadLine();
+            goto root;
+
+        logCompression:
+            Console.WriteLine();
+            Console.WriteLine("Options:");
+            foreach (var compressionType in (LogCompression[])Enum.GetValues(typeof(LogCompression)))
+            {
+                Console.WriteLine($"{compressionType.ToString().ToLowerInvariant(),-15} => {compressionType.LongName()}");
+            }
+
+            Console.WriteLine();
+            Console.WriteLine("Input the log compression type and press Enter:");
+            Console.Write("> ");
+            result = Console.ReadLine();
+            Options.LogCompression = result.ToLogCompression();
+            goto root;
+
+        exit:
+            // Now deal with the complex options
+            Options.ScanForProtection = scan && !string.IsNullOrEmpty(DevicePath);
+            Options.ScanArchivesForProtection = enableArchives && scan && !string.IsNullOrEmpty(DevicePath);
+            Options.IncludeDebugProtectionInformation = enableDebug && scan && !string.IsNullOrEmpty(DevicePath);
+            Options.HideDriveLetters = hideDriveLetters && scan && !string.IsNullOrEmpty(DevicePath);
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => Inputs.Count > 0;
+    }
+}

MPF.Check/Features/MainFeature.cs

@@ -0,0 +1,272 @@
+using System;
+using MPF.Frontend;
+using MPF.Frontend.Tools;
+using SabreTools.CommandLine.Inputs;
+using SabreTools.RedumpLib;
+using SabreTools.RedumpLib.Data;
+using LogCompression = MPF.Processors.LogCompression;
+
+namespace MPF.Check.Features
+{
+    internal sealed class MainFeature : BaseFeature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "main";
+
+        /// <remarks>Flags are unused</remarks>
+        private static readonly string[] _flags = [];
+
+        /// <remarks>Description is unused</remarks>
+        private const string _description = "";
+
+        #endregion
+
+        #region Inputs
+
+        private const string _createIrdName = "create-ird";
+        internal readonly FlagInput CreateIrdInput = new(_createIrdName, "--create-ird", "Create IRD from output files (PS3 only)");
+
+        private const string _deleteName = "delete";
+        internal readonly FlagInput DeleteInput = new(_deleteName, ["-d", "--delete"], "Enable unnecessary file deletion");
+
+        private const string _disableArchivesName = "disable-archives";
+        internal readonly FlagInput DisableArchivesInput = new(_disableArchivesName, "--disable-archives", "Disable scanning archives (requires --scan)");
+
+        private const string _enableDebugName = "enable-debug";
+        internal readonly FlagInput EnableDebugInput = new(_enableDebugName, "--enable-debug", "Enable debug protection information (requires --scan)");
+
+        private const string _hideDriveLettersName = "hide-drive-letters";
+        internal readonly FlagInput HideDriveLettersInput = new(_hideDriveLettersName, "--hide-drive-letters", "Hide drive letters from scan output (requires --scan)");
+
+        private const string _includeArtifactsName = "include-artifacts";
+        internal readonly FlagInput IncludeArtifactsInput = new(_includeArtifactsName, "--include-artifacts", "Include artifacts in JSON (requires --json)");
+
+        private const string _jsonName = "json";
+        internal readonly FlagInput JsonInput = new(_jsonName, ["-j", "--json"], "Enable submission JSON output");
+
+        private const string _loadSeedName = "load-seed";
+        internal readonly StringInput LoadSeedInput = new(_loadSeedName, "--load-seed", "Load a seed submission JSON for user information");
+
+        private const string _logCompressionName = "log-compression";
+        internal readonly StringInput LogCompressionInput = new(_logCompressionName, "--log-compression", "Set the log compression type (requires compression enabled)");
+
+        private const string _noPlaceholdersName = "no-placeholders";
+        internal readonly FlagInput NoPlaceholdersInput = new(_noPlaceholdersName, "--no-placeholders", "Disable placeholder values in submission info");
+
+        private const string _noRetrieveName = "no-retrieve";
+        internal readonly FlagInput NoRetrieveInput = new(_noRetrieveName, "--no-retrieve", "Disable retrieving match information from Redump");
+
+        private const string _passwordName = "password";
+        internal readonly StringInput PasswordInput = new(_passwordName, ["-P", "--password"], "Redump password (incompatible with --no-retrieve)");
+
+        private const string _pathName = "path";
+        internal readonly StringInput PathInput = new(_pathName, ["-p", "--path"], "Physical drive path for additional checks");
+
+        private const string _pullAllName = "pull-all";
+        internal readonly FlagInput PullAllInput = new(_pullAllName, "--pull-all", "Pull all information from Redump (requires --username and --password)");
+
+        private const string _scanName = "scan";
+        internal readonly FlagInput ScanInput = new(_scanName, ["-s", "--scan"], "Enable copy protection scan (requires --path)");
+
+        private const string _suffixName = "suffix";
+        internal readonly FlagInput SuffixInput = new(_suffixName, ["-x", "--suffix"], "Enable adding filename suffix");
+
+        private const string _useName = "use";
+        internal readonly StringInput UseInput = new(_useName, ["-u", "--use"], "Override configured dumping program name");
+
+        private const string _usernameName = "username";
+        internal readonly StringInput UsernameInput = new(_usernameName, ["-U", "--username"], "Redump username (incompatible with --no-retrieve)");
+
+        private const string _zipName = "zip";
+        internal readonly FlagInput ZipInput = new(_zipName, ["-z", "--zip"], "Enable log file compression");
+
+        #endregion
+
+        public MainFeature()
+            : base(DisplayName, _flags, _description)
+        {
+            Add(UseInput);
+            Add(LoadSeedInput);
+            Add(NoPlaceholdersInput);
+            Add(CreateIrdInput);
+            Add(NoRetrieveInput);
+            // TODO: Figure out how to work with the credentials input
+            Add(PullAllInput);
+            Add(PathInput);
+            Add(ScanInput);
+            Add(DisableArchivesInput);
+            Add(EnableDebugInput);
+            Add(HideDriveLettersInput);
+            Add(SuffixInput);
+            Add(JsonInput);
+            Add(IncludeArtifactsInput);
+            Add(ZipInput);
+            Add(LogCompressionInput);
+            Add(DeleteInput);
+        }
+
+        /// <inheritdoc/>
+        public override bool ProcessArgs(string[] args, int index)
+        {
+            // 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)
+                return true;
+
+            // Read the options from config, if possible
+            Options = OptionsLoader.LoadFromConfig();
+            if (Options.FirstRun)
+            {
+                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,
+                    LogCompression = LogCompression.DeflateMaximum,
+                    DeleteUnnecessaryFiles = false,
+                    CreateIRDAfterDumping = false,
+
+                    // Protection Scanning Options
+                    ScanArchivesForProtection = true,
+                    IncludeDebugProtectionInformation = false,
+                    HideDriveLetters = false,
+
+                    // Redump Login Information
+                    RetrieveMatchInformation = true,
+                    RedumpUsername = null,
+                    RedumpPassword = null,
+                };
+            }
+            else
+            {
+                Console.WriteLine("Options will be loaded from found configuration file!");
+            }
+
+            // The first argument is the system type
+            System = args[0].Trim('"').ToRedumpSystem();
+
+            // Loop through the arguments and parse out values
+            for (index = 1; index < args.Length; index++)
+            {
+                // Use specific program
+                if (UseInput.ProcessInput(args, ref index))
+                    Options.InternalProgram = UseInput.Value.ToInternalProgram();
+
+                // Include seed info file
+                else if (LoadSeedInput.ProcessInput(args, ref index))
+                    Seed = Builder.CreateFromFile(LoadSeedInput.Value);
+
+                // Disable placeholder values in submission info
+                else if (NoPlaceholdersInput.ProcessInput(args, ref index))
+                    Options.AddPlaceholders = !Options.AddPlaceholders;
+
+                // Create IRD from output files (PS3 only)
+                else if (CreateIrdInput.ProcessInput(args, ref index))
+                    Options.CreateIRDAfterDumping = !Options.CreateIRDAfterDumping;
+
+                // Set the log compression type (requires compression enabled)
+                else if (LogCompressionInput.ProcessInput(args, ref index))
+                    Options.LogCompression = LogCompressionInput.Value.ToLogCompression();
+
+                // Retrieve Redump match information
+                else if (NoRetrieveInput.ProcessInput(args, ref index))
+                    Options.RetrieveMatchInformation = !Options.RetrieveMatchInformation;
+
+                // Redump login
+                else if (args[index].StartsWith("-c=") || args[index].StartsWith("--credentials="))
+                {
+                    string[] credentials = args[index].Split('=')[1].Split(';');
+                    Options.RedumpUsername = credentials[0];
+                    Options.RedumpPassword = credentials[1];
+                }
+                else if (args[index] == "-c" || args[index] == "--credentials")
+                {
+                    Options.RedumpUsername = args[index + 1];
+                    Options.RedumpPassword = args[index + 2];
+                    index += 2;
+                }
+
+                // Redump username
+                else if (UsernameInput.ProcessInput(args, ref index))
+                    Options.RedumpUsername = UsernameInput.Value;
+
+                // Redump password
+                else if (PasswordInput.ProcessInput(args, ref index))
+                    Options.RedumpPassword = PasswordInput.Value;
+
+                // Pull all information (requires Redump login)
+                else if (PullAllInput.ProcessInput(args, ref index))
+                    Options.PullAllInformation = !Options.PullAllInformation;
+
+                // Use a device path for physical checks
+                else if (PathInput.ProcessInput(args, ref index))
+                    DevicePath = PathInput.Value;
+
+                // Scan for protection (requires device path)
+                else if (ScanInput.ProcessInput(args, ref index))
+                    scan = true;
+
+                // Disable scanning archives (requires --scan)
+                else if (ScanInput.ProcessInput(args, ref index))
+                    enableArchives = false;
+
+                // Enable debug protection information (requires --scan)
+                else if (EnableDebugInput.ProcessInput(args, ref index))
+                    enableDebug = true;
+
+                // Hide drive letters from scan output (requires --scan)
+                else if (HideDriveLettersInput.ProcessInput(args, ref index))
+                    hideDriveLetters = true;
+
+                // Add filename suffix
+                else if (SuffixInput.ProcessInput(args, ref index))
+                    Options.AddFilenameSuffix = !Options.AddFilenameSuffix;
+
+                // Output submission JSON
+                else if (JsonInput.ProcessInput(args, ref index))
+                    Options.OutputSubmissionJSON = !Options.OutputSubmissionJSON;
+
+                // Include JSON artifacts
+                else if (IncludeArtifactsInput.ProcessInput(args, ref index))
+                    Options.IncludeArtifacts = !Options.IncludeArtifacts;
+
+                // Compress log and extraneous files
+                else if (ZipInput.ProcessInput(args, ref index))
+                    Options.CompressLogFiles = !Options.CompressLogFiles;
+
+                // Delete unnecessary files
+                else if (DeleteInput.ProcessInput(args, ref index))
+                    Options.DeleteUnnecessaryFiles = !Options.DeleteUnnecessaryFiles;
+
+                // Default, add to inputs
+                else
+                    Inputs.Add(args[index]);
+            }
+
+            // Now deal with the complex options
+            Options.ScanForProtection = scan && !string.IsNullOrEmpty(DevicePath);
+            Options.ScanArchivesForProtection = enableArchives && scan && !string.IsNullOrEmpty(DevicePath);
+            Options.IncludeDebugProtectionInformation = enableDebug && scan && !string.IsNullOrEmpty(DevicePath);
+            Options.HideDriveLetters = hideDriveLetters && scan && !string.IsNullOrEmpty(DevicePath);
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => Inputs.Count > 0;
+    }
+}

MPF.Check/MPF.Check.csproj

@@ -1,22 +1,24 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<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</TargetFrameworks>
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0;net10.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.2.2</VersionPrefix>
+        <VersionPrefix>3.6.0</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-2024</Copyright>
+        <Copyright>Copyright (c) Matt Nadareski 2019-2025</Copyright>
         <PackageProjectUrl>https://github.com/SabreTools/</PackageProjectUrl>
         <RepositoryUrl>https://github.com/SabreTools/MPF</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
@@ -29,37 +31,20 @@
     <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`))">
+    <PropertyGroup Condition="$(TargetFramework.StartsWith(`net6`)) OR $(TargetFramework.StartsWith(`net7`)) OR $(TargetFramework.StartsWith(`net8`)) OR $(TargetFramework.StartsWith(`net9`)) OR $(TargetFramework.StartsWith(`net10`))">
         <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</TargetFrameworks>
+        <TargetFrameworks>net6.0;net7.0;net8.0;net9.0;net10.0</TargetFrameworks>
     </PropertyGroup>
 
-    <ItemGroup>
-        <None Include="App.config" />
-    </ItemGroup>
-
-    <!-- Support for old .NET versions -->
-    <ItemGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net40`))">
-        <PackageReference Include="MinAsyncBridge" Version="0.12.4" />
-        <PackageReference Include="MinTasksExtensionsBridge" Version="0.3.4" />
-        <PackageReference Include="MinThreadingBridge" Version="0.11.4" />
-    </ItemGroup>
-
     <ItemGroup>
         <ProjectReference Include="..\MPF.Frontend\MPF.Frontend.csproj" />
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.13" GeneratePathProperty="true">
-            <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
-        </PackageReference>
-        <PackageReference Include="SabreTools.RedumpLib" Version="1.4.1" />
-    </ItemGroup>
-
-    <ItemGroup>
-        <Content Include="$(PkgBinaryObjectScanner)\content\**" PackagePath="contentFiles\any\any;content" CopyToOutputDirectory="Always" PackageCopyToOutput="true" />
+        <PackageReference Include="SabreTools.CommandLine" Version="[1.4.0]" />
+        <PackageReference Include="SabreTools.RedumpLib" Version="[1.9.0]" />
     </ItemGroup>
 
 </Project>

MPF.Check/Program.cs

@@ -1,15 +1,12 @@
 using System;
-using System.IO;
+using System.Collections.Generic;
 #if NET40
-using System.Threading;
 using System.Threading.Tasks;
 #endif
-using BinaryObjectScanner;
-using MPF.Frontend;
-using MPF.Frontend.Tools;
-using SabreTools.RedumpLib;
-using SabreTools.RedumpLib.Data;
-using SabreTools.RedumpLib.Web;
+using MPF.Check.Features;
+using MPF.Frontend.Features;
+using SabreTools.CommandLine;
+using SabreTools.CommandLine.Features;
 
 namespace MPF.Check
 {
@@ -17,323 +14,128 @@ namespace MPF.Check
     {
         public static void Main(string[] args)
         {
-            // Create a default options object
-            var options = new Frontend.Options()
+            // Create the command set
+            var mainFeature = new MainFeature();
+            var commandSet = CreateCommands(mainFeature);
+
+            // If we have no args, show the help and quit
+            if (args == null || args.Length == 0)
             {
-                // Internal Program
-                InternalProgram = InternalProgram.NONE,
+                BaseFeature.DisplayHelp();
+                return;
+            }
 
-                // 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,
-                ScanPackersForProtection = false,
-                IncludeDebugProtectionInformation = false,
-                HideDriveLetters = false,
-
-                // Redump Login Information
-                RedumpUsername = null,
-                RedumpPassword = null,
-            };
+            // Get the first argument as a feature flag
+            string featureName = args[0];
 
             // Try processing the standalone arguments
-            bool? standaloneProcessed = OptionsLoader.ProcessStandaloneArguments(args);
-            if (standaloneProcessed != false)
+            var topLevel = commandSet.GetTopLevel(featureName);
+            switch (topLevel)
             {
-                if (standaloneProcessed == null)
-                    DisplayHelp();
-                return;
-            }
+                // Standalone Options
+                case Help: BaseFeature.DisplayHelp(); return;
+                case VersionFeature version: version.Execute(); return;
+                case ListCodesFeature lc: lc.Execute(); return;
+                case ListConfigFeature lc: lc.Execute(); return;
+                case ListMediaTypesFeature lm: lm.Execute(); return;
+                case ListProgramsFeature lp: lp.Execute(); return;
+                case ListSystemsFeature ls: ls.Execute(); return;
 
-            // Try processing the common arguments
-            (bool success, MediaType mediaType, RedumpSystem? knownSystem, var error) = OptionsLoader.ProcessCommonArguments(args);
-            if (!success)
-            {
-                DisplayHelp(error);
-                return;
-            }
+                // Interactive Mode
+                case InteractiveFeature interactive:
+                    if (!interactive.ProcessArgs(args, 0))
+                    {
+                        BaseFeature.DisplayHelp();
+                        return;
+                    }
+                    if (!interactive.VerifyInputs())
+                    {
+                        Console.Error.WriteLine("At least one input is required");
+                        BaseFeature.DisplayHelp();
+                        return;
+                    }
+                    if (!interactive.Execute())
+                    {
+                        BaseFeature.DisplayHelp();
+                        return;
+                    }
+
+                    break;
+
+                // Default Behavior
+                default:
+                    if (!mainFeature.ProcessArgs(args, 0))
+                    {
+                        BaseFeature.DisplayHelp();
+                        return;
+                    }
+                    if (!mainFeature.VerifyInputs())
+                    {
+                        Console.Error.WriteLine("At least one input is required");
+                        BaseFeature.DisplayHelp();
+                        return;
+                    }
+                    if (!mainFeature.Execute())
+                    {
+                        BaseFeature.DisplayHelp();
+                        return;
+                    }
 
-            // Loop through and process options
-            (CommandOptions opts, int startIndex) = LoadFromArguments(args, options, startIndex: 2);
-            if (options.InternalProgram == InternalProgram.NONE)
-            {
-                DisplayHelp("A program name needs to be provided");
-                return;
-            }
-
-            // Make new Progress objects
-            var resultProgress = new Progress<ResultEventArgs>();
-            resultProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
-            var protectionProgress = new Progress<ProtectionProgress>();
-            protectionProgress.ProgressChanged += ConsoleLogger.ProgressUpdated;
-
-            // Validate the supplied credentials
-            (bool? _, string? message) = RedumpClient.ValidateCredentials(options.RedumpUsername ?? string.Empty, options.RedumpPassword ?? string.Empty).GetAwaiter().GetResult();
-            if (!string.IsNullOrEmpty(message))
-                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, mediaType, internalProgram: null, parameters: null);
-
-                // Finally, attempt to do the output dance
-                var result = env.VerifyAndSaveDumpOutput(resultProgress, protectionProgress, seedInfo: opts.Seed).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 <mediatype> <system> [options] </path/to/output.cue/iso> ...");
-            Console.WriteLine();
-            Console.WriteLine("Standalone Options:");
-            Console.WriteLine("-h, -?                  Show this help text");
-            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();
-
-            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("-c, --credentials <user> <pw>  Redump username and password");
-            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-packers           Enable scanning for packers (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();
-        }
-
-        /// <summary>
-        /// Load the current set of options from application arguments
-        /// </summary>
-        private static (CommandOptions, int) LoadFromArguments(string[] args, Frontend.Options options, int startIndex = 0)
-        {
-            // Create return values
-            var opts = new CommandOptions();
-
-            // These values require multiple parts to be active
-            bool scan = false,
-                enableArchives = true,
-                enablePackers = false,
-                enableDebug = false,
-                hideDriveLetters = false;
-
-            // If we have no arguments, just return
-            if (args == null || args.Length == 0)
-                return (opts, 0);
-
-            // If we have an invalid start index, just return
-            if (startIndex < 0 || startIndex >= args.Length)
-                return (opts, startIndex);
-
-            // 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 = Frontend.Options.ToInternalProgram(internalProgram);
-                }
-                else if (args[startIndex] == "-u" || args[startIndex] == "--use")
-                {
-                    string internalProgram = args[startIndex + 1];
-                    options.InternalProgram = Frontend.Options.ToInternalProgram(internalProgram);
-                    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;
-                }
-
-                // 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 scanning for packers (requires --scan)
-                else if (args[startIndex].Equals("--enable-packers"))
-                {
-                    enablePackers = true;
-                }
-
-                // 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;
-                }
-
-                // Output submission JSON
-                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 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.ScanPackersForProtection = enablePackers && scan && !string.IsNullOrEmpty(opts.DevicePath);
-            options.IncludeDebugProtectionInformation = enableDebug && scan && !string.IsNullOrEmpty(opts.DevicePath);
-            options.HideDriveLetters = hideDriveLetters && scan && !string.IsNullOrEmpty(opts.DevicePath);
-
-            return (opts, startIndex);
         }
 
         /// <summary>
-        /// Represents commandline options
+        /// Create the command set for the program
         /// </summary>
-        private class CommandOptions
+        private static CommandSet CreateCommands(MainFeature mainFeature)
         {
-            /// <summary>
-            /// Seed submission info from an input file
-            /// </summary>
-            public SubmissionInfo? Seed { get; set; } = null;
+            List<string> header = [
+                "MPF.CLI [standalone|system] [options] <path> ...",
+                string.Empty,
+            ];
 
-            /// <summary>
-            /// Path to the device to scan
-            /// </summary>
-            public string? DevicePath { get; set; } = null;
+            List<string> footer = [
+                string.Empty,
+                "WARNING: Check will overwrite both any existing submission information files as well",
+                "as any log archives. Please make backups of those if you need to before running Check.",
+                string.Empty,
+            ];
+
+            var commandSet = new CommandSet(header, footer);
+
+            // Standalone Options
+            commandSet.Add(new Help());
+            commandSet.Add(new VersionFeature());
+            commandSet.Add(new ListCodesFeature());
+            commandSet.Add(new ListConfigFeature());
+            commandSet.Add(new ListMediaTypesFeature());
+            commandSet.Add(new ListSystemsFeature());
+            commandSet.Add(new ListProgramsFeature());
+            commandSet.Add(new InteractiveFeature());
+
+            // Check Options
+            commandSet.Add(mainFeature.UseInput);
+            commandSet.Add(mainFeature.LoadSeedInput);
+            commandSet.Add(mainFeature.NoPlaceholdersInput);
+            commandSet.Add(mainFeature.CreateIrdInput);
+            commandSet.Add(mainFeature.NoRetrieveInput);
+            commandSet.Add(mainFeature.UsernameInput);
+            commandSet.Add(mainFeature.PasswordInput);
+            commandSet.Add(mainFeature.PullAllInput);
+            commandSet.Add(mainFeature.PathInput);
+            commandSet.Add(mainFeature.ScanInput);
+            commandSet.Add(mainFeature.DisableArchivesInput);
+            commandSet.Add(mainFeature.EnableDebugInput);
+            commandSet.Add(mainFeature.HideDriveLettersInput);
+            commandSet.Add(mainFeature.SuffixInput);
+            commandSet.Add(mainFeature.JsonInput);
+            commandSet.Add(mainFeature.IncludeArtifactsInput);
+            commandSet.Add(mainFeature.ZipInput);
+            commandSet.Add(mainFeature.LogCompressionInput);
+            commandSet.Add(mainFeature.DeleteInput);
+
+            return commandSet;
         }
     }
 }

MPF.Check/launchSettings.json

@@ -1,7 +0,0 @@
-{
-  "profiles": {
-    "MPF.Check": {
-      "commandName": "Project"
-    }
-  }
-}

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 readonly 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 readonly 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)
+        {
+            var 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)
+        {
+            var 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)
+        {
+            var 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)
+        {
+            var 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)
+        {
+            var 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)
+        {
+            var 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)
+        {
+            var 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)
+        {
+            var 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)
+        {
+            var 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)
+        {
+            var 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)
+        {
+            var 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

@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>net6.0;net8.0</TargetFrameworks>
+        <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
         <CheckEolTargetFramework>false</CheckEolTargetFramework>
         <LangVersion>latest</LangVersion>
         <Nullable>enable</Nullable>
@@ -11,26 +11,25 @@
 
     <ItemGroup>
         <ProjectReference Include="..\MPF.ExecutionContexts\MPF.ExecutionContexts.csproj" />
-        <ProjectReference Include="..\MPF.Frontend\MPF.Frontend.csproj" />
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.CodeCoverage" Version="17.10.0-release-24177-07" />
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0-release-24177-07" />
-        <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-        <PackageReference Include="SabreTools.RedumpLib" Version="1.4.1" />
-        <PackageReference Include="xunit" Version="2.8.0" />
+        <PackageReference Include="Microsoft.CodeCoverage" Version="18.0.0" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
+        <PackageReference Include="SabreTools.RedumpLib" Version="[1.9.0]" />
+        <PackageReference Include="xunit" Version="2.9.3" />
         <PackageReference Include="xunit.abstractions" Version="2.0.3" />
-        <PackageReference Include="xunit.analyzers" Version="1.13.0" />
-        <PackageReference Include="xunit.assert" Version="2.8.0" />
-        <PackageReference Include="xunit.core" Version="2.8.0" />
-        <PackageReference Include="xunit.extensibility.core" Version="2.8.0" />
-        <PackageReference Include="xunit.extensibility.execution" Version="2.8.0" />
-        <PackageReference Include="xunit.runner.console" Version="2.8.0">
+        <PackageReference Include="xunit.analyzers" Version="1.25.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="2.8.0">
+        <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>

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 readonly 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 --skeleton --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 --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.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

@@ -7,25 +7,35 @@ namespace MPF.ExecutionContexts.Aaru
     {
         public const string NONE = "";
 
-        // Archive Family
+        #region Archive Family
+
         public const string ArchivePrefixShort = "arc";
         public const string ArchivePrefixLong = "archive";
         public const string ArchiveInfo = "info";
 
-        // Database Family
+        #endregion
+
+        #region Database Family
+
         public const string DatabasePrefixShort = "db";
         public const string DatabasePrefixLong = "database";
         public const string DatabaseStats = "stats";
         public const string DatabaseUpdate = "update";
 
-        // Device Family
+        #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";
 
-        // Filesystem Family
+        #endregion
+
+        #region Filesystem Family
+
         public const string FilesystemPrefixShort = "fi";
         public const string FilesystemPrefixShortAlt = "fs";
         public const string FilesystemPrefixLong = "filesystem";
@@ -35,7 +45,10 @@ namespace MPF.ExecutionContexts.Aaru
         public const string FilesystemListLong = "list";
         public const string FilesystemOptions = "options";
 
-        // Image Family
+        #endregion
+
+        #region Image Family
+
         public const string ImagePrefixShort = "i";
         public const string ImagePrefixLong = "image";
         public const string ImageChecksumShort = "chk";
@@ -51,18 +64,26 @@ namespace MPF.ExecutionContexts.Aaru
         public const string ImagePrint = "print";
         public const string ImageVerify = "verify";
 
-        // Media Family
+        #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";
 
-        // Standalone Commands
+        #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/EncodingStrings.cs

@@ -40,4 +40,4 @@ namespace MPF.ExecutionContexts.Aaru
         public const string WesternEuropeanMac = "macintosh";
         public const string WesternEuropeanRadix50 = "radix50";
     }
-}
+}

MPF.ExecutionContexts/Aaru/FlagStrings.cs

@@ -5,7 +5,21 @@ namespace MPF.ExecutionContexts.Aaru
     /// </summary>
     public static class FlagStrings
     {
-        // Boolean flags
+        #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";
@@ -14,8 +28,6 @@ namespace MPF.ExecutionContexts.Aaru
         public const string CRC32Short = "-c";
         public const string CRC32Long = "--crc32";
         public const string CRC64Long = "--crc64";
-        public const string DebugShort = "-d";
-        public const string DebugLong = "--debug";
         public const string DiskTagsShort = "-f";
         public const string DiskTagsLong = "--disk-tags";
         public const string DuplicatedSectorsShort = "-p";
@@ -35,9 +47,6 @@ namespace MPF.ExecutionContexts.Aaru
         public const string ForceShort = "-f";
         public const string ForceLong = "--force";
         public const string GenerateSubchannelsLong = "--generate-subchannels";
-        public const string HelpShort = "-h";
-        public const string HelpShortAlt = "-?";
-        public const string HelpLong = "--help";
         public const string LongFormatShort = "-l";
         public const string LongFormatLong = "--long-format";
         public const string LongSectorsShort = "-r";
@@ -75,26 +84,32 @@ namespace MPF.ExecutionContexts.Aaru
         public const string TrapDiscLong = "--trap-disc";
         public const string TrimLong = "--trim";
         public const string UseBufferedReadsLong = "--use-buffered-reads";
-        public const string VerboseShort = "-v";
-        public const string VerboseLong = "--verbose";
         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 VersionLong = "--version";
         public const string WholeDiscShort = "-w";
         public const string WholeDiscLong = "--whole-disc";
 
-        // Int8 flags
+        #endregion
+
+        #region Int8 flags
+
         public const string SpeedLong = "--speed";
 
-        // Int16 flags
+        #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";
 
-        // Int32 flags
+        #endregion
+
+        #region Int32 flags
+
         public const string BlockSizeShort = "-b";
         public const string BlockSizeLong = "--block-size";
         public const string CountShort = "-c";
@@ -105,13 +120,19 @@ namespace MPF.ExecutionContexts.Aaru
         public const string SkipShort = "-k";
         public const string SkipLong = "--skip";
 
-        // Int64 flags
+        #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";
 
-        // String flags
+        #endregion
+
+        #region String flags
+
         public const string CommentsLong = "--comments";
         public const string CreatorLong = "--creator";
         public const string DriveManufacturerLong = "--drive-manufacturer";
@@ -121,9 +142,8 @@ namespace MPF.ExecutionContexts.Aaru
         public const string EncodingShort = "-e";
         public const string EncodingLong = "--encoding";
         public const string FormatConvertShort = "-p";
-        public const string FormatConvertLong = "--format";
         public const string FormatDumpShort = "-t";
-        public const string FormatDumpLong = "--format";
+        public const string FormatLong = "--format";
         public const string GeometryShort = "-g";
         public const string GeometryLong = "--geometry";
         public const string ImgBurnLogShort = "-b";
@@ -147,5 +167,7 @@ namespace MPF.ExecutionContexts.Aaru
         public const string SubchannelLong = "--subchannel";
         public const string XMLSidecarShort = "-x";
         public const string XMLSidecarLong = "--cicm-xml";
+
+        #endregion
     }
-}
+}

MPF.ExecutionContexts/Aaru/FormatStrings.cs

@@ -166,4 +166,4 @@ namespace MPF.ExecutionContexts.Aaru
         public const string XboxPartitioning = "Xbox partitioning";
         public const string XENIX = "XENIX";
     }
-}
+}

MPF.ExecutionContexts/Aaru/NamespaceStrings.cs

@@ -24,4 +24,4 @@ namespace MPF.ExecutionContexts.Aaru
         public const string WindowsNT83MixedCase = "nt";
         public const string OS2Extended = "os2";
     }
-}
+}

MPF.ExecutionContexts/Aaru/OptionStrings.cs

@@ -40,4 +40,4 @@ namespace MPF.ExecutionContexts.Aaru
         public const string VMwareDiskImageSparse = "sparse"; // boolean, default false
         public const string VMwareDiskImageSplit = "split"; // boolean, default false
     }
-}
+}

MPF.ExecutionContexts/Aaru/SettingConstants.cs

@@ -17,4 +17,4 @@ namespace MPF.ExecutionContexts.Aaru
         public const string StripPersonalData = "AaruStripPersonalData";
         public const bool StripPersonalDataDefault = false;
     }
-}
+}

MPF.ExecutionContexts/BaseExecutionContext.cs

@@ -20,7 +20,7 @@ namespace MPF.ExecutionContexts
         /// Set of flags to pass to the executable
         /// </summary>
         protected Dictionary<string, bool?> flags = [];
-        protected internal IEnumerable<string> Keys => flags.Keys;
+        protected internal List<string> Keys => [.. flags.Keys];
 
         /// <summary>
         /// Safe access to currently set flags
@@ -82,12 +82,12 @@ namespace MPF.ExecutionContexts
         /// <summary>
         /// Currently represented system
         /// </summary>
-        public RedumpSystem? System { get; set; }
+        public RedumpSystem? RedumpSystem { get; set; }
 
         /// <summary>
         /// Currently represented media type
         /// </summary>
-        public MediaType? Type { get; set; }
+        public MediaType? MediaType { get; set; }
 
         #endregion
 
@@ -111,10 +111,15 @@ namespace MPF.ExecutionContexts
         /// <param name="filename">Filename to use</param>
         /// <param name="driveSpeed">Drive speed to use</param>
         /// <param name="options">Dictionary object containing all settings that may be used for setting parameters</param>
-        public BaseExecutionContext(RedumpSystem? system, MediaType? type, string? drivePath, string filename, int? driveSpeed, Dictionary<string, string?> options)
+        public BaseExecutionContext(RedumpSystem? system,
+            MediaType? type,
+            string? drivePath,
+            string filename,
+            int? driveSpeed,
+            Dictionary<string, string?> options)
         {
-            this.System = system;
-            this.Type = type;
+            RedumpSystem = system;
+            MediaType = type;
             SetDefaultParameters(drivePath, filename, driveSpeed, options);
         }
 
@@ -169,7 +174,10 @@ namespace MPF.ExecutionContexts
         /// <param name="filename">Filename to use</param>
         /// <param name="driveSpeed">Drive speed to use</param>
         /// <param name="options">Dictionary containing all settings that may be used for setting parameters</param>
-        protected abstract void SetDefaultParameters(string? drivePath, string filename, int? driveSpeed, Dictionary<string, string?> options);
+        protected abstract void SetDefaultParameters(string? drivePath,
+            string filename,
+            int? driveSpeed,
+            Dictionary<string, string?> options);
 
         /// <summary>
         /// Scan a possible parameter string and populate whatever possible
@@ -234,7 +242,7 @@ namespace MPF.ExecutionContexts
         /// <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>
-        protected static bool GetBooleanSetting(Dictionary<string, string?> settings, string key, bool defaultValue)
+        internal static bool GetBooleanSetting(Dictionary<string, string?> settings, string key, bool defaultValue)
         {
             if (settings.ContainsKey(key))
             {
@@ -256,7 +264,7 @@ namespace MPF.ExecutionContexts
         /// <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>
-        protected static int GetInt32Setting(Dictionary<string, string?> settings, string key, int defaultValue)
+        internal static int GetInt32Setting(Dictionary<string, string?> settings, string key, int defaultValue)
         {
             if (settings.ContainsKey(key))
             {
@@ -278,7 +286,7 @@ namespace MPF.ExecutionContexts
         /// <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>
-        protected static string? GetStringSetting(Dictionary<string, string?> settings, string key, string? defaultValue)
+        internal static string? GetStringSetting(Dictionary<string, string?> settings, string key, string? defaultValue)
         {
             if (settings.ContainsKey(key))
                 return settings[key];
@@ -290,14 +298,31 @@ namespace MPF.ExecutionContexts
 
         #region Parameter Parsing
 
+        /// <summary>
+        /// Split a parameters string into a list while taking quotes into account
+        /// </summary>
+        internal static string[] SplitParameterString(string parameters)
+        {
+            // Ensure the parameter string is trimmed
+            parameters = parameters.Trim();
+
+            // Split the string using Regex
+            var matches = Regex.Matches(parameters, @"([a-zA-Z0-9\-]*=)?[\""].+?[\""]|[^ ]+", RegexOptions.Compiled);
+
+            // Get just the values from the matches
+            var matchArr = new Match[matches.Count];
+            matches.CopyTo(matchArr, 0);
+            return Array.ConvertAll(matchArr, m => m.Value);
+        }
+
         /// <summary>
         /// Returns whether or not the selected item exists
         /// </summary>
-        /// <param name="parameters">List of parameters to check against</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="index">Current index</param>
         /// <returns>True if the next item exists, false otherwise</returns>
-        protected static bool DoesExist(List<string> parameters, int index)
-            => index < parameters.Count;
+        internal static bool DoesExist(string[] parts, int index)
+            => index >= 0 && index < parts.Length;
 
         /// <summary>
         /// Gets if the flag is supported by the current command
@@ -308,9 +333,9 @@ namespace MPF.ExecutionContexts
         {
             if (CommandSupport == null)
                 return false;
-            if (this.BaseCommand == null)
+            if (BaseCommand == null)
                 return false;
-            if (!CommandSupport.TryGetValue(this.BaseCommand, out var supported))
+            if (!CommandSupport.TryGetValue(BaseCommand, out var supported))
                 return false;
             return supported.Contains(flag);
         }
@@ -320,7 +345,7 @@ namespace MPF.ExecutionContexts
         /// </summary>
         /// <param name="parameter">String value to check</param>
         /// <returns>True if it's a valid bool, false otherwise</returns>
-        protected static bool IsValidBool(string parameter)
+        internal static bool IsValidBool(string parameter)
             => bool.TryParse(parameter, out bool _);
 
         /// <summary>
@@ -330,14 +355,14 @@ namespace MPF.ExecutionContexts
         /// <param name="lowerBound">Lower bound (>=)</param>
         /// <param name="upperBound">Upper bound (<=)</param>
         /// <returns>True if it's a valid byte, false otherwise</returns>
-        protected static bool IsValidInt8(string parameter, sbyte lowerBound = -1, sbyte upperBound = -1)
+        internal static bool IsValidInt8(string parameter, sbyte? lowerBound = null, sbyte? upperBound = null)
         {
-            (string value, long _) = ExtractFactorFromValue(parameter);
+            string value = ExtractFactorFromValue(parameter, out _);
             if (!sbyte.TryParse(value, out sbyte temp))
                 return false;
-            else if (lowerBound != -1 && temp < lowerBound)
+            else if (lowerBound != null && temp < lowerBound)
                 return false;
-            else if (upperBound != -1 && temp > upperBound)
+            else if (upperBound != null && temp > upperBound)
                 return false;
 
             return true;
@@ -350,14 +375,14 @@ namespace MPF.ExecutionContexts
         /// <param name="lowerBound">Lower bound (>=)</param>
         /// <param name="upperBound">Upper bound (<=)</param>
         /// <returns>True if it's a valid Int16, false otherwise</returns>
-        protected static bool IsValidInt16(string parameter, short lowerBound = -1, short upperBound = -1)
+        internal static bool IsValidInt16(string parameter, short? lowerBound = null, short? upperBound = null)
         {
-            (string value, long _) = ExtractFactorFromValue(parameter);
+            string value = ExtractFactorFromValue(parameter, out _);
             if (!short.TryParse(value, out short temp))
                 return false;
-            else if (lowerBound != -1 && temp < lowerBound)
+            else if (lowerBound != null && temp < lowerBound)
                 return false;
-            else if (upperBound != -1 && temp > upperBound)
+            else if (upperBound != null && temp > upperBound)
                 return false;
 
             return true;
@@ -370,14 +395,14 @@ namespace MPF.ExecutionContexts
         /// <param name="lowerBound">Lower bound (>=)</param>
         /// <param name="upperBound">Upper bound (<=)</param>
         /// <returns>True if it's a valid Int32, false otherwise</returns>
-        protected static bool IsValidInt32(string parameter, int lowerBound = -1, int upperBound = -1)
+        internal static bool IsValidInt32(string parameter, int? lowerBound = null, int? upperBound = null)
         {
-            (string value, long _) = ExtractFactorFromValue(parameter);
+            string value = ExtractFactorFromValue(parameter, out _);
             if (!int.TryParse(value, out int temp))
                 return false;
-            else if (lowerBound != -1 && temp < lowerBound)
+            else if (lowerBound != null && temp < lowerBound)
                 return false;
-            else if (upperBound != -1 && temp > upperBound)
+            else if (upperBound != null && temp > upperBound)
                 return false;
 
             return true;
@@ -390,14 +415,14 @@ namespace MPF.ExecutionContexts
         /// <param name="lowerBound">Lower bound (>=)</param>
         /// <param name="upperBound">Upper bound (<=)</param>
         /// <returns>True if it's a valid Int64, false otherwise</returns>
-        protected static bool IsValidInt64(string parameter, long lowerBound = -1, long upperBound = -1)
+        internal static bool IsValidInt64(string parameter, long? lowerBound = null, long? upperBound = null)
         {
-            (string value, long _) = ExtractFactorFromValue(parameter);
+            string value = ExtractFactorFromValue(parameter, out _);
             if (!long.TryParse(value, out long temp))
                 return false;
-            else if (lowerBound != -1 && temp < lowerBound)
+            else if (lowerBound != null && temp < lowerBound)
                 return false;
-            else if (upperBound != -1 && temp > upperBound)
+            else if (upperBound != null && temp > upperBound)
                 return false;
 
             return true;
@@ -406,22 +431,22 @@ namespace MPF.ExecutionContexts
         /// <summary>
         /// Process a flag parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="flagString">Flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
-        protected bool ProcessFlagParameter(List<string> parts, string flagString, ref int i)
+        protected bool ProcessFlagParameter(string[] parts, string flagString, ref int i)
             => ProcessFlagParameter(parts, null, flagString, ref i);
 
         /// <summary>
         /// Process a flag parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="shortFlagString">Short flag string, if available</param>
         /// <param name="longFlagString">Long flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
-        protected bool ProcessFlagParameter(List<string> parts, string? shortFlagString, string longFlagString, ref int i)
+        protected bool ProcessFlagParameter(string[] parts, string? shortFlagString, string longFlagString, ref int i)
         {
             if (parts == null)
                 return false;
@@ -440,24 +465,24 @@ namespace MPF.ExecutionContexts
         /// <summary>
         /// Process a boolean parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="flagString">Flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
-        protected bool ProcessBooleanParameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        protected bool ProcessBooleanParameter(string[] parts, string flagString, ref int i, bool missingAllowed = false)
             => ProcessBooleanParameter(parts, null, flagString, ref i, missingAllowed);
 
         /// <summary>
         /// Process a boolean parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="shortFlagString">Short flag string, if available</param>
         /// <param name="longFlagString">Long flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>True if the parameter was processed successfully or skipped, false otherwise</returns>
-        protected bool ProcessBooleanParameter(List<string> parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        protected bool ProcessBooleanParameter(string[] parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
         {
             if (parts == null)
                 return false;
@@ -515,24 +540,24 @@ namespace MPF.ExecutionContexts
         /// <summary>
         /// Process a sbyte parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="flagString">Flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>SByte value if success, SByte.MinValue if skipped, null on error/returns>
-        protected sbyte? ProcessInt8Parameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        protected sbyte? ProcessInt8Parameter(string[] parts, string flagString, ref int i, bool missingAllowed = false)
             => ProcessInt8Parameter(parts, null, flagString, ref i, missingAllowed);
 
         /// <summary>
         /// Process an sbyte parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="shortFlagString">Short flag string, if available</param>
         /// <param name="longFlagString">Long flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>SByte value if success, SByte.MinValue if skipped, null on error/returns>
-        protected sbyte? ProcessInt8Parameter(List<string> parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        protected sbyte? ProcessInt8Parameter(string[] parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
         {
             if (parts == null)
                 return null;
@@ -568,7 +593,7 @@ namespace MPF.ExecutionContexts
                 this[longFlagString] = true;
                 i++;
 
-                (string value, long factor) = ExtractFactorFromValue(parts[i]);
+                string value = ExtractFactorFromValue(parts[i], out long factor);
                 if (sbyte.TryParse(value, out sbyte sByteValue))
                     return (sbyte)(sByteValue * factor);
                 string hexValue = RemoveHexIdentifier(value);
@@ -588,7 +613,7 @@ namespace MPF.ExecutionContexts
                 string valuePart = commandParts[1];
 
                 this[longFlagString] = true;
-                (string value, long factor) = ExtractFactorFromValue(valuePart);
+                string value = ExtractFactorFromValue(valuePart, out long factor);
                 if (sbyte.TryParse(value, out sbyte sByteValue))
                     return (sbyte)(sByteValue * factor);
                 string hexValue = RemoveHexIdentifier(value);
@@ -603,24 +628,24 @@ namespace MPF.ExecutionContexts
         /// <summary>
         /// Process an Int16 parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="flagString">Flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>Int16 value if success, Int16.MinValue if skipped, null on error/returns>
-        protected short? ProcessInt16Parameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        protected short? ProcessInt16Parameter(string[] parts, string flagString, ref int i, bool missingAllowed = false)
             => ProcessInt16Parameter(parts, null, flagString, ref i, missingAllowed);
 
         /// <summary>
         /// Process an Int16 parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="shortFlagString">Short flag string, if available</param>
         /// <param name="longFlagString">Long flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>Int16 value if success, Int16.MinValue if skipped, null on error/returns>
-        protected short? ProcessInt16Parameter(List<string> parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        protected short? ProcessInt16Parameter(string[] parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
         {
             if (parts == null)
                 return null;
@@ -655,7 +680,7 @@ namespace MPF.ExecutionContexts
 
                 this[longFlagString] = true;
                 i++;
-                (string value, long factor) = ExtractFactorFromValue(parts[i]);
+                string value = ExtractFactorFromValue(parts[i], out long factor);
                 if (short.TryParse(value, out short shortValue))
                     return (short)(shortValue * factor);
                 string hexValue = RemoveHexIdentifier(value);
@@ -675,7 +700,7 @@ namespace MPF.ExecutionContexts
                 string valuePart = commandParts[1];
 
                 this[longFlagString] = true;
-                (string value, long factor) = ExtractFactorFromValue(valuePart);
+                string value = ExtractFactorFromValue(valuePart, out long factor);
                 if (short.TryParse(value, out short shortValue))
                     return (short)(shortValue * factor);
                 string hexValue = RemoveHexIdentifier(value);
@@ -690,24 +715,24 @@ namespace MPF.ExecutionContexts
         /// <summary>
         /// Process an Int32 parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="flagString">Flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>Int32 value if success, Int32.MinValue if skipped, null on error/returns>
-        protected int? ProcessInt32Parameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        protected int? ProcessInt32Parameter(string[] parts, string flagString, ref int i, bool missingAllowed = false)
             => ProcessInt32Parameter(parts, null, flagString, ref i, missingAllowed);
 
         /// <summary>
         /// Process an Int32 parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="shortFlagString">Short flag string, if available</param>
         /// <param name="longFlagString">Long flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>Int32 value if success, Int32.MinValue if skipped, null on error/returns>
-        protected int? ProcessInt32Parameter(List<string> parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        protected int? ProcessInt32Parameter(string[] parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
         {
             if (parts == null)
                 return null;
@@ -742,7 +767,7 @@ namespace MPF.ExecutionContexts
 
                 this[longFlagString] = true;
                 i++;
-                (string value, long factor) = ExtractFactorFromValue(parts[i]);
+                string value = ExtractFactorFromValue(parts[i], out long factor);
                 if (int.TryParse(value, out int intValue))
                     return (int)(intValue * factor);
                 string hexValue = RemoveHexIdentifier(value);
@@ -762,7 +787,7 @@ namespace MPF.ExecutionContexts
                 string valuePart = commandParts[1];
 
                 this[longFlagString] = true;
-                (string value, long factor) = ExtractFactorFromValue(valuePart);
+                string value = ExtractFactorFromValue(valuePart, out long factor);
                 if (int.TryParse(value, out int intValue))
                     return (int)(intValue * factor);
                 string hexValue = RemoveHexIdentifier(value);
@@ -771,30 +796,30 @@ namespace MPF.ExecutionContexts
                 return null;
             }
 
-            return Int32.MinValue;
+            return int.MinValue;
         }
 
         /// <summary>
         /// Process an Int64 parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="flagString">Flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>Int64 value if success, Int64.MinValue if skipped, null on error/returns>
-        protected long? ProcessInt64Parameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        protected long? ProcessInt64Parameter(string[] parts, string flagString, ref int i, bool missingAllowed = false)
             => ProcessInt64Parameter(parts, null, flagString, ref i, missingAllowed);
 
         /// <summary>
         /// Process an Int64 parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="shortFlagString">Short flag string, if available</param>
         /// <param name="longFlagString">Long flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>Int64 value if success, Int64.MinValue if skipped, null on error/returns>
-        protected long? ProcessInt64Parameter(List<string> parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        protected long? ProcessInt64Parameter(string[] parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
         {
             if (parts == null)
                 return null;
@@ -829,7 +854,7 @@ namespace MPF.ExecutionContexts
 
                 this[longFlagString] = true;
                 i++;
-                (string value, long factor) = ExtractFactorFromValue(parts[i]);
+                string value = ExtractFactorFromValue(parts[i], out long factor);
                 if (long.TryParse(value, out long longValue))
                     return (long)(longValue * factor);
                 string hexValue = RemoveHexIdentifier(value);
@@ -849,7 +874,7 @@ namespace MPF.ExecutionContexts
                 string valuePart = commandParts[1];
 
                 this[longFlagString] = true;
-                (string value, long factor) = ExtractFactorFromValue(valuePart);
+                string value = ExtractFactorFromValue(valuePart, out long factor);
                 if (long.TryParse(value, out long longValue))
                     return (long)(longValue * factor);
                 string hexValue = RemoveHexIdentifier(value);
@@ -858,30 +883,30 @@ namespace MPF.ExecutionContexts
                 return null;
             }
 
-            return Int64.MinValue;
+            return long.MinValue;
         }
 
         /// <summary>
         /// Process an string parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="flagString">Flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>String value if possible, string.Empty on missing, null on error</returns>
-        protected string? ProcessStringParameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        protected string? ProcessStringParameter(string[] parts, string flagString, ref int i, bool missingAllowed = false)
             => ProcessStringParameter(parts, null, flagString, ref i, missingAllowed);
 
         /// <summary>
         /// Process a string parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="shortFlagString">Short flag string, if available</param>
         /// <param name="longFlagString">Long flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>String value if possible, string.Empty on missing, null on error</returns>
-        protected string? ProcessStringParameter(List<string> parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        protected string? ProcessStringParameter(string[] parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
         {
             if (parts == null)
                 return null;
@@ -937,24 +962,24 @@ namespace MPF.ExecutionContexts
         /// <summary>
         /// Process a byte parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="flagString">Flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>Byte value if success, Byte.MinValue if skipped, null on error/returns>
-        protected byte? ProcessUInt8Parameter(List<string> parts, string flagString, ref int i, bool missingAllowed = false)
+        protected byte? ProcessUInt8Parameter(string[] parts, string flagString, ref int i, bool missingAllowed = false)
             => ProcessUInt8Parameter(parts, null, flagString, ref i, missingAllowed);
 
         /// <summary>
         /// Process a byte parameter
         /// </summary>
-        /// <param name="parts">List of parts to be referenced</param>
+        /// <param name="parts">Parts array to be referenced</param>
         /// <param name="shortFlagString">Short flag string, if available</param>
         /// <param name="longFlagString">Long flag string, if available</param>
         /// <param name="i">Reference to the position in the parts</param>
         /// <param name="missingAllowed">True if missing values are allowed, false otherwise</param>
         /// <returns>Byte value if success, Byte.MinValue if skipped, null on error/returns>
-        protected byte? ProcessUInt8Parameter(List<string> parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
+        protected byte? ProcessUInt8Parameter(string[] parts, string? shortFlagString, string longFlagString, ref int i, bool missingAllowed = false)
         {
             if (parts == null)
                 return null;
@@ -990,7 +1015,7 @@ namespace MPF.ExecutionContexts
                 this[longFlagString] = true;
                 i++;
 
-                (string value, long factor) = ExtractFactorFromValue(parts[i]);
+                string value = ExtractFactorFromValue(parts[i], out long factor);
                 if (byte.TryParse(value, out byte byteValue))
                     return (byte)(byteValue * factor);
                 string hexValue = RemoveHexIdentifier(value);
@@ -1010,7 +1035,7 @@ namespace MPF.ExecutionContexts
                 string valuePart = commandParts[1];
 
                 this[longFlagString] = true;
-                (string value, long factor) = ExtractFactorFromValue(valuePart);
+                string value = ExtractFactorFromValue(valuePart, out long factor);
                 if (byte.TryParse(value, out byte byteValue))
                     return (byte)(byteValue * factor);
                 string hexValue = RemoveHexIdentifier(value);
@@ -1027,10 +1052,10 @@ namespace MPF.ExecutionContexts
         /// </summary>
         /// <param name="value">String value to treat as suffixed number</param>
         /// <returns>Trimmed value and multiplication factor</returns>
-        private static (string trimmed, long factor) ExtractFactorFromValue(string value)
+        internal static string ExtractFactorFromValue(string value, out long factor)
         {
             value = value.Trim('"');
-            long factor = 1;
+            factor = 1;
 
             // Characters
             if (value.EndsWith("c", StringComparison.Ordinal))
@@ -1081,7 +1106,7 @@ namespace MPF.ExecutionContexts
                 value = value.TrimEnd('G');
             }
 
-            return (value, factor);
+            return value;
         }
 
         /// <summary>
@@ -1089,7 +1114,7 @@ namespace MPF.ExecutionContexts
         /// </summary>
         /// <param name="value">String with removed leading 0x</param>
         /// <returns></returns>
-        private static string RemoveHexIdentifier(string value)
+        internal static string RemoveHexIdentifier(string value)
         {
             if (value.Length <= 2)
                 return value;

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,291 @@
+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 NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+            if (value.EndsWith('c'))
+#else
+            if (value.EndsWith("c", System.StringComparison.Ordinal))
+#endif
+            {
+                factor = 1;
+                value = value.TrimEnd('c');
+            }
+
+            // Words
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+            else if (value.EndsWith('w'))
+#else
+            else if (value.EndsWith("w", System.StringComparison.Ordinal))
+#endif
+            {
+                factor = 2;
+                value = value.TrimEnd('w');
+            }
+
+            // Double Words
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+            else if (value.EndsWith('d'))
+#else
+            else if (value.EndsWith("d", System.StringComparison.Ordinal))
+#endif
+            {
+                factor = 4;
+                value = value.TrimEnd('d');
+            }
+
+            // Quad Words
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+            else if (value.EndsWith('q'))
+#else
+            else if (value.EndsWith("q", System.StringComparison.Ordinal))
+#endif
+            {
+                factor = 8;
+                value = value.TrimEnd('q');
+            }
+
+            // Kilobytes
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+            else if (value.EndsWith('k'))
+#else
+            else if (value.EndsWith("k", System.StringComparison.Ordinal))
+#endif
+            {
+                factor = 1024;
+                value = value.TrimEnd('k');
+            }
+
+            // Megabytes
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+            else if (value.EndsWith('M'))
+#else
+            else if (value.EndsWith("M", System.StringComparison.Ordinal))
+#endif
+            {
+                factor = 1024 * 1024;
+                value = value.TrimEnd('M');
+            }
+
+            // Gigabytes
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+            else if (value.EndsWith('G'))
+#else
+            else if (value.EndsWith("G", System.StringComparison.Ordinal))
+#endif
+            {
+                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;
+
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+            return value[2..];
+#else
+            return value.Substring(2);
+#endif
+        }
+
+        #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

@@ -32,4 +32,4 @@ namespace MPF.ExecutionContexts.DiscImageCreator
         public const string XGD2Swap = "xgd2swap";
         public const string XGD3Swap = "xgd3swap";
     }
-}
+}

MPF.ExecutionContexts/DiscImageCreator/Converters.cs

@@ -97,4 +97,4 @@ namespace MPF.ExecutionContexts.DiscImageCreator
 
         #endregion
     }
-}
+}

MPF.ExecutionContexts/DiscImageCreator/FlagStrings.cs

@@ -10,6 +10,7 @@ namespace MPF.ExecutionContexts.DiscImageCreator
         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";
@@ -17,7 +18,9 @@ namespace MPF.ExecutionContexts.DiscImageCreator
         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";
@@ -37,9 +40,11 @@ namespace MPF.ExecutionContexts.DiscImageCreator
         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

@@ -23,4 +23,4 @@ namespace MPF.ExecutionContexts.DiscImageCreator
         public const string UseCMIFlag = "DICUseCMIFlag";
         public const bool UseCMIFlagDefault = false;
     }
-}
+}

MPF.ExecutionContexts/MPF.ExecutionContexts.csproj

@@ -1,59 +1,38 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<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</TargetFrameworks>
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0;net10.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.2.2</VersionPrefix>
+        <VersionPrefix>3.6.0</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-2024</Copyright>
+        <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.Test" />
-    </ItemGroup>
-
-    <!-- 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`))">
-        <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</TargetFrameworks>
-    </PropertyGroup>
-
-    <!-- Support for old .NET versions -->
-    <ItemGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net40`))">
-        <PackageReference Include="MinAsyncBridge" Version="0.12.4" />
-        <PackageReference Include="MinTasksExtensionsBridge" Version="0.3.4" />
-        <PackageReference Include="MinThreadingBridge" Version="0.11.4" />
-    </ItemGroup>
-    <ItemGroup Condition="$(TargetFramework.StartsWith(`net4`)) AND !$(TargetFramework.StartsWith(`net40`))">
-        <PackageReference Include="IndexRange" Version="1.0.3" />
-    </ItemGroup>
-    <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND !$(TargetFramework.StartsWith(`net40`)) AND !$(TargetFramework.StartsWith(`net452`))">
-        <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+        <None Include="README.md" Pack="true" PackagePath="" />
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="SabreTools.RedumpLib" Version="1.4.1" />
+        <InternalsVisibleTo Include="MPF.ExecutionContexts.Test" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <PackageReference Include="SabreTools.RedumpLib" Version="[1.9.0]" />
     </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

@@ -6,23 +6,27 @@ namespace MPF.ExecutionContexts.Redumper
     public static class CommandStrings
     {
         public const string NONE = "";
-        public const string CD = "cd";
-        public const string DVD = "dvd"; // Synonym for CD
-        public const string BluRay = "bd"; // Synonym for CD
-        public const string SACD = "sacd"; // Synonym for CD
-        public const string New = "new"; // Synonym for CD; Temporary command, to be removed later
+        public const string Disc = "disc";
         public const string Rings = "rings";
         public const string Dump = "dump";
-        public const string DumpNew = "dumpnew"; // Temporary command, to be removed later
+        public const string DumpExtra = "dump::extra";
         public const string Refine = "refine";
-        public const string RefineNew = "refinenew"; // Temporary command, to be removed later
         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

@@ -15,14 +15,18 @@ namespace MPF.ExecutionContexts.Redumper
         {
             return type switch
             {
-                MediaType.CDROM => ".bin",
+                MediaType.CDROM
+                    or MediaType.GDROM => ".bin",
                 MediaType.DVD
                     or MediaType.HDDVD
-                    or MediaType.BluRay => ".iso",
+                    or MediaType.BluRay
+                    or MediaType.NintendoWiiOpticalDisc => ".iso",
+                MediaType.NintendoGameCubeGameDisc => ".raw",
+                MediaType.NintendoWiiUOpticalDisc => ".wud",
                 _ => null,
             };
         }
 
         #endregion
     }
-}
+}

MPF.ExecutionContexts/Redumper/Enumerations.cs

@@ -1,5 +1,21 @@
 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>
@@ -9,7 +25,6 @@ namespace MPF.ExecutionContexts.Redumper
 
         BE,
         D8,
-        BE_CDDA,
     }
 
     /// <summary>
@@ -24,4 +39,4 @@ namespace MPF.ExecutionContexts.Redumper
         DATA_SUB,
         DATA_C2,
     }
-}
+}

MPF.ExecutionContexts/Redumper/FlagStrings.cs

@@ -5,20 +5,28 @@ namespace MPF.ExecutionContexts.Redumper
     /// </summary>
     public static class FlagStrings
     {
-        // General
+        #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 Debug = "--debug";
+        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
 
-        // Drive Configuration
         public const string DriveType = "--drive-type";
         public const string DriveReadOffset = "--drive-read-offset";
         public const string DriveC2Shift = "--drive-c2-shift";
@@ -26,34 +34,71 @@ namespace MPF.ExecutionContexts.Redumper
         public const string DriveReadMethod = "--drive-read-method";
         public const string DriveSectorOrder = "--drive-sector-order";
 
-        // Drive Specific
+        #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
 
-        // 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";
 
-        // Split
+        #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";
 
-        // Miscellaneous
+        #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";
+        public const string CdrErrorThreshold = "--cdr-error-threshold";
+
+        #endregion
+
+        #region Undocumented
+
+        public const string Debug = "--debug";
         public const string LegacySubs = "--legacy-subs";
-        public const string DisableCDText = "--disable-cdtext";
+
+        #endregion
     }
-}
+}

MPF.ExecutionContexts/Redumper/SettingConstants.cs

@@ -2,28 +2,31 @@ namespace MPF.ExecutionContexts.Redumper
 {
     public static class SettingConstants
     {
-        public const string EnableDebug = "RedumperEnableDebug";
-        public const bool EnableDebugDefault = false;
+        public const string DriveType = "RedumperDriveType";
+        public static readonly string DriveTypeDefault = Redumper.DriveType.NONE.ToString();
 
-        public const string EnableLeadinRetry = "RedumperEnableLeadinRetry";
-        public const bool EnableLeadinRetryDefault = false;
+        public const string EnableSkeleton = "RedumperEnableSkeleton";
+        public const bool EnableSkeletonDefault = true;
 
         public const string EnableVerbose = "RedumperEnableVerbose";
-        public const bool EnableVerboseDefault = true;
+        public const bool EnableVerboseDefault = false;
 
         public const string LeadinRetryCount = "RedumperLeadinRetryCount";
         public const int LeadinRetryCountDefault = 4;
 
+        public const string DrivePregapStart = "RedumperDrivePregapStart";
+        public const int DrivePregapStartDefault = 0;
+
         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();
-
-        public const string UseGenericDriveType = "RedumperUseGenericDriveType";
-        public const bool UseGenericDriveTypeDefault = false;
     }
-}
+}

MPF.Frontend.Test/DriveTests.cs

@@ -1,15 +1,13 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using MPF.Frontend;
 using Xunit;
 
-namespace MPF.Test.Frontend
+namespace MPF.Frontend.Test
 {
-    public class EnumConverterTests
+    public class DriveTests
     {
-        #region Cross-enumeration conversions
+        #region ToInternalDriveType
 
         /// <summary>
         /// DiscType values that map to InternalDriveType
@@ -45,9 +43,9 @@ namespace MPF.Test.Frontend
         public static List<object?[]> GenerateDriveTypeMappingTestData()
         {
             var testData = new List<object?[]>() { new object?[] { null, true } };
-            foreach (DriveType driveType in Enum.GetValues(typeof(DriveType)))
+            foreach (DriveType driveType in Enum.GetValues<DriveType>())
             {
-                if (_mappableDriveTypes.Contains(driveType))
+                if (Array.IndexOf(_mappableDriveTypes, driveType) > -1)
                     testData.Add([driveType, false]);
                 else
                     testData.Add([driveType, true]);
@@ -57,40 +55,5 @@ namespace MPF.Test.Frontend
         }
 
         #endregion
-
-        #region Convert to Long Name
-
-        // TODO: Maybe add a test for the generic "GetLongName" method
-
-        /// <summary>
-        /// Check that every InternalProgram has a long name provided
-        /// </summary>
-        /// <param name="internalProgram">InternalProgram value to check</param>
-        [Theory]
-        [MemberData(nameof(GenerateInternalProgramTestData))]
-        public void InternalProgramLongNameTest(InternalProgram? internalProgram)
-        {
-            string actual = internalProgram.LongName();
-            Assert.NotNull(actual);
-        }
-
-        /// <summary>
-        /// Generate a test set of InternalProgram values
-        /// </summary>
-        /// <returns>MemberData-compatible list of InternalProgram values</returns>
-        public static List<object?[]> GenerateInternalProgramTestData()
-        {
-            var testData = new List<object?[]>() { new object?[] { null } };
-            foreach (InternalProgram? internalProgram in Enum.GetValues(typeof(InternalProgram)))
-            {
-                testData.Add([internalProgram]);
-            }
-
-            return testData;
-        }
-
-        #endregion
-
-        // TODO: Add from-string tests
     }
 }

MPF.Frontend.Test/DumpEnvironmentTests.cs

@@ -1,8 +1,7 @@
-using MPF.Frontend;
-using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Data;
 using Xunit;
 
-namespace MPF.Test.Frontend
+namespace MPF.Frontend.Test
 {
     public class DumpEnvironmentTests
     {
@@ -10,6 +9,7 @@ namespace MPF.Test.Frontend
         [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)]
@@ -22,9 +22,15 @@ namespace MPF.Test.Frontend
                 ? Drive.Create(InternalDriveType.Floppy, letter.ToString())
                 : Drive.Create(InternalDriveType.Optical, letter.ToString());
 
-            var env = new DumpEnvironment(options, string.Empty, drive, RedumpSystem.IBMPCcompatible, mediaType, null, parameters);
+            var env = new DumpEnvironment(options,
+                string.Empty,
+                drive,
+                RedumpSystem.IBMPCcompatible,
+                null);
+            env.SetExecutionContext(mediaType, parameters);
+            env.SetProcessor();
 
-            bool actual = env.ParametersValid();
+            bool actual = env.ParametersValid(mediaType);
             Assert.Equal(expected, actual);
         }
     }

MPF.Frontend.Test/EnumExtensionsTests.cs

@@ -0,0 +1,293 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using SabreTools.RedumpLib.Data;
+using Xunit;
+using LogCompression = MPF.Processors.LogCompression;
+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(InterfaceLanguage.AutoDetect, "Auto Detect")]
+        [InlineData(InterfaceLanguage.English, "English")]
+        [InlineData(InterfaceLanguage.French, "Français")]
+        [InlineData(InterfaceLanguage.German, "Deutsch")]
+        [InlineData(InterfaceLanguage.Italian, "Italiano")]
+        [InlineData(InterfaceLanguage.Japanese, "日本語")]
+        [InlineData(InterfaceLanguage.Korean, "한국어")]
+        [InlineData(InterfaceLanguage.Polish, "Polski")]
+        [InlineData(InterfaceLanguage.Russian, "Русский")]
+        [InlineData(InterfaceLanguage.Spanish, "Español")]
+        [InlineData(InterfaceLanguage.Swedish, "Svenska")]
+        [InlineData(InterfaceLanguage.Ukrainian, "Українська")]
+        [InlineData(InterfaceLanguage.L337, "L337")]
+        public void LongName_InterfaceLanguage(InterfaceLanguage? lang, string? expected)
+        {
+            string? actual = lang.LongName();
+            Assert.Equal(expected, actual);
+
+            if (lang != null)
+            {
+                actual = EnumExtensions.GetLongName(lang);
+                Assert.Equal(expected, actual);
+            }
+        }
+
+        [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);
+
+            if (prog != null)
+            {
+                actual = EnumExtensions.GetLongName(prog);
+                Assert.Equal(expected, actual);
+            }
+        }
+
+        [Theory]
+        [InlineData(null, "Unknown")]
+        [InlineData(LogCompression.DeflateDefault, "ZIP using Deflate (Level 5)")]
+        [InlineData(LogCompression.DeflateMaximum, "ZIP using Deflate (Level 9)")]
+        [InlineData(LogCompression.Zstd19, "ZIP using Zstd (Level 19)")]
+        public void LongName_LogCompression(LogCompression? comp, string? expected)
+        {
+            string? actual = comp.LongName();
+            Assert.Equal(expected, actual);
+
+            if (comp != null)
+            {
+                actual = EnumExtensions.GetLongName(comp);
+                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);
+
+            if (method != null)
+            {
+                actual = EnumExtensions.GetLongName(method);
+                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);
+
+            if (order != null)
+            {
+                actual = EnumExtensions.GetLongName(order);
+                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);
+
+            if (type != null)
+            {
+                actual = EnumExtensions.GetLongName(type);
+                Assert.Equal(expected, actual);
+            }
+        }
+
+        #endregion
+
+        #region Short Name
+
+        [Theory]
+        [InlineData(null, "Unknown")]
+        [InlineData(InterfaceLanguage.AutoDetect, "auto")]
+        [InlineData(InterfaceLanguage.English, "eng")]
+        [InlineData(InterfaceLanguage.French, "fra")]
+        [InlineData(InterfaceLanguage.German, "deu")]
+        [InlineData(InterfaceLanguage.Italian, "ita")]
+        [InlineData(InterfaceLanguage.Japanese, "jpn")]
+        [InlineData(InterfaceLanguage.Korean, "kor")]
+        [InlineData(InterfaceLanguage.Polish, "pol")]
+        [InlineData(InterfaceLanguage.Russian, "rus")]
+        [InlineData(InterfaceLanguage.Spanish, "spa")]
+        [InlineData(InterfaceLanguage.Swedish, "swe")]
+        [InlineData(InterfaceLanguage.Ukrainian, "ukr")]
+        [InlineData(InterfaceLanguage.L337, "l37")]
+        public void ShortName_InterfaceLanguage(InterfaceLanguage? lang, string? expected)
+        {
+            string? actual = lang.ShortName();
+            Assert.Equal(expected, actual);
+        }
+
+        [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, InterfaceLanguage.AutoDetect)]
+        [InlineData("", InterfaceLanguage.AutoDetect)]
+        [InlineData("auto", InterfaceLanguage.AutoDetect)]
+        [InlineData("eng", InterfaceLanguage.English)]
+        [InlineData("fra", InterfaceLanguage.French)]
+        [InlineData("deu", InterfaceLanguage.German)]
+        [InlineData("ita", InterfaceLanguage.Italian)]
+        [InlineData("jpn", InterfaceLanguage.Japanese)]
+        [InlineData("kor", InterfaceLanguage.Korean)]
+        [InlineData("pol", InterfaceLanguage.Polish)]
+        [InlineData("rus", InterfaceLanguage.Russian)]
+        [InlineData("spa", InterfaceLanguage.Spanish)]
+        [InlineData("swe", InterfaceLanguage.Swedish)]
+        [InlineData("ukr", InterfaceLanguage.Ukrainian)]
+        [InlineData("l37", InterfaceLanguage.L337)]
+        public void ToInterfaceLanguageTest(string? interfaceLanguage, InterfaceLanguage expected)
+        {
+            InterfaceLanguage actual = interfaceLanguage.ToInterfaceLanguage();
+            Assert.Equal(expected, actual);
+        }
+
+        [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.DVDVideo,
+            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<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<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[^1]);
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFrameworks>net8.0;net9.0;net10.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="18.0.0" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.0.0" />
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.4" />
+        <PackageReference Include="SabreTools.RedumpLib" Version="[1.9.0]" />
+        <PackageReference Include="xunit" Version="2.9.3" />
+        <PackageReference Include="xunit.abstractions" Version="2.0.3" />
+        <PackageReference Include="xunit.analyzers" Version="1.25.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

@@ -1,7 +1,6 @@
-using MPF.Frontend;
-using Xunit;
+using Xunit;
 
-namespace MPF.Test.Frontend
+namespace MPF.Frontend.Test
 {
     public class ResultEventArgsTests
     {

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)
+        {
+            var 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

@@ -1,34 +1,15 @@
 using System.Collections.Generic;
-using System.IO;
-using MPF.Frontend.Tools;
 using SabreTools.RedumpLib;
 using SabreTools.RedumpLib.Data;
+using SabreTools.RedumpLib.Data.Sections;
 using Xunit;
 
-namespace MPF.Test.Frontend.Tools
+namespace MPF.Frontend.Test.Tools
 {
     public class InfoToolTests
     {
-        [Theory]
-        [InlineData(null, "")]
-        [InlineData(" ", " ")]
-        [InlineData("super\\blah.bin", "super\\blah.bin")]
-        [InlineData("super\\hero\\blah.bin", "super\\hero\\blah.bin")]
-        [InlineData("super.hero\\blah.bin", "super.hero\\blah.bin")]
-        [InlineData("superhero\\blah.rev.bin", "superhero\\blah.rev.bin")]
-        [InlineData("super&hero\\blah.bin", "super&hero\\blah.bin")]
-        [InlineData("superhero\\blah&foo.bin", "superhero\\blah&foo.bin")]
-        public void NormalizeOutputPathsTest(string? outputPath, string? expectedPath)
-        {
-            if (!string.IsNullOrEmpty(expectedPath))
-                expectedPath = Path.GetFullPath(expectedPath);
-
-            string actualPath = FrontendTool.NormalizeOutputPaths(outputPath, true);
-            Assert.Equal(expectedPath, actualPath);
-        }
-
         [Fact]
-        public void ProcessSpecialFieldsCompleteTest()
+        public void ProcessSpecialFields_Complete()
         {
             // Create a new SubmissionInfo object
             var info = new SubmissionInfo()
@@ -54,9 +35,9 @@ namespace MPF.Test.Frontend.Tools
 
             // Validate the basics
             Assert.NotNull(info.CommonDiscInfo.Comments);
-            Assert.Null(info.CommonDiscInfo.CommentsSpecialFields);
+            Assert.Empty(info.CommonDiscInfo.CommentsSpecialFields);
             Assert.NotNull(info.CommonDiscInfo.Contents);
-            Assert.Null(info.CommonDiscInfo.ContentsSpecialFields);
+            Assert.Empty(info.CommonDiscInfo.ContentsSpecialFields);
 
             // Split the values
             string[] splitComments = info.CommonDiscInfo.Comments.Split('\n');
@@ -64,27 +45,11 @@ namespace MPF.Test.Frontend.Tools
 
             // Validate the lines
             Assert.Equal(3, splitComments.Length);
-            Assert.Equal(5, splitContents.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()
+        public void ProcessSpecialFields_NullStrings()
         {
             // Create a new SubmissionInfo object
             var info = new SubmissionInfo()
@@ -110,9 +75,9 @@ namespace MPF.Test.Frontend.Tools
 
             // Validate the basics
             Assert.NotNull(info.CommonDiscInfo.Comments);
-            Assert.Null(info.CommonDiscInfo.CommentsSpecialFields);
+            Assert.Empty(info.CommonDiscInfo.CommentsSpecialFields);
             Assert.NotNull(info.CommonDiscInfo.Contents);
-            Assert.Null(info.CommonDiscInfo.ContentsSpecialFields);
+            Assert.Empty(info.CommonDiscInfo.ContentsSpecialFields);
 
             // Split the values
             string[] splitComments = info.CommonDiscInfo.Comments.Split('\n');
@@ -124,7 +89,7 @@ namespace MPF.Test.Frontend.Tools
         }
 
         [Fact]
-        public void ProcessSpecialFieldsNullDictionariesTest()
+        public void ProcessSpecialFields_EmptyDictionaries()
         {
             // Create a new SubmissionInfo object
             var info = new SubmissionInfo()
@@ -132,10 +97,10 @@ namespace MPF.Test.Frontend.Tools
                 CommonDiscInfo = new CommonDiscInfoSection()
                 {
                     Comments = "This is a comments line\n[T:ISBN] ISBN Value",
-                    CommentsSpecialFields = null,
+                    CommentsSpecialFields = [],
 
                     Contents = "This is a contents line\n[T:GF] Game Footage",
-                    ContentsSpecialFields = null,
+                    ContentsSpecialFields = [],
                 }
             };
 
@@ -144,9 +109,9 @@ namespace MPF.Test.Frontend.Tools
 
             // Validate the basics
             Assert.NotNull(info.CommonDiscInfo.Comments);
-            Assert.Null(info.CommonDiscInfo.CommentsSpecialFields);
+            Assert.Empty(info.CommonDiscInfo.CommentsSpecialFields);
             Assert.NotNull(info.CommonDiscInfo.Contents);
-            Assert.Null(info.CommonDiscInfo.ContentsSpecialFields);
+            Assert.Empty(info.CommonDiscInfo.ContentsSpecialFields);
 
             // Split the values
             string[] splitComments = info.CommonDiscInfo.Comments.Split('\n');

MPF.Frontend.Test/Tools/ProtectionToolTests.cs

@@ -0,0 +1,824 @@
+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)];
+
+            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)];
+
+            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)];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal(protections[0], sanitized);
+        }
+
+        [Fact]
+        public void SanitizeFoundProtections_StarForce_Keyless()
+        {
+            List<string> protections =
+            [
+                "StarForce Keyless",
+                "StarForce Keyless - ",
+                "StarForce Keyless - ESPY97LS8FHNYR52JDWL8D6FJ",
+                "StarForce Keyless - UAYA-RPMVHJ-ZRY45G-ETUJ36-WL922B",
+            ];
+
+            string sanitized = ProtectionTool.SanitizeFoundProtections(protections);
+            Assert.Equal("StarForce Keyless", 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

@@ -1,24 +1,23 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 
 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
+    /// <typeparam name="TEnum">Enum type representing the possible values</typeparam>
+    public class Element<TEnum> : IEquatable<Element<TEnum>>, IElement where TEnum : struct, Enum
     {
-        private readonly T Data;
+        private readonly TEnum Data;
 
-        public Element(T data) => Data = data;
+        public Element(TEnum 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;
+        public static implicit operator TEnum?(Element<TEnum> item) => item?.Data;
 
         /// <inheritdoc/>
         public string Name => EnumExtensions.GetLongName(Data);
@@ -28,7 +27,7 @@ namespace MPF.Frontend.ComboBoxItems
         /// <summary>
         /// Internal enum value
         /// </summary>
-        public T Value => Data;
+        public TEnum Value => Data;
 
         /// <summary>
         /// Determine if the item is selected or not
@@ -40,21 +39,20 @@ namespace MPF.Frontend.ComboBoxItems
         /// Generate all elements associated with the data enum type
         /// </summary>
         /// <returns></returns>
-        public static IEnumerable<Element<T>> GenerateElements()
+        public static List<Element<TEnum>> GenerateElements()
         {
-            return Enum.GetValues(typeof(T))
-                .OfType<T>()
-                .Select(e => new Element<T>(e));
+            var enumArr = (TEnum[])Enum.GetValues(typeof(TEnum));
+            return [.. Array.ConvertAll(enumArr, e => new Element<TEnum>(e))];
         }
 
         /// <inheritdoc/>
         public override bool Equals(object? obj)
         {
-            return Equals(obj as Element<T>);
+            return Equals(obj as Element<TEnum>);
         }
 
         /// <inheritdoc/>
-        public bool Equals(Element<T>? other)
+        public bool Equals(Element<TEnum>? other)
         {
             if (other == null)
                 return false;

MPF.Frontend/ComboBoxItems/RedumpSystemComboBoxItem.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
+#if NET35_OR_GREATER || NETCOREAPP
 using System.Linq;
+#endif
 using SabreTools.RedumpLib.Data;
 
 namespace MPF.Frontend.ComboBoxItems
@@ -50,13 +52,26 @@ namespace MPF.Frontend.ComboBoxItems
         /// Generate all elements for the known system combo box
         /// </summary>
         /// <returns></returns>
-        public static IEnumerable<RedumpSystemComboBoxItem> GenerateElements()
+        public static List<RedumpSystemComboBoxItem> GenerateElements()
         {
-            var knownSystems = Enum.GetValues(typeof(RedumpSystem))
-                .OfType<RedumpSystem?>()
-                .Where(s => !s.IsMarker() && s.GetCategory() != SystemCategory.NONE)
-                .ToList();
+            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(
@@ -65,10 +80,11 @@ namespace MPF.Frontend.ComboBoxItems
                         .OrderBy(s => s.LongName())
                         .ToList()
                 );
+#endif
 
             var systemsValues = new List<RedumpSystemComboBoxItem>
             {
-                new RedumpSystemComboBoxItem((RedumpSystem?)null),
+                new((RedumpSystem?)null),
             };
 
             foreach (var group in mapping)

MPF.Frontend/ConsoleLogger.cs

@@ -1,8 +1,7 @@
 using System;
 using BinaryObjectScanner;
-using MPF.Frontend;
 
-namespace MPF.CLI
+namespace MPF.Frontend
 {
     public static class ConsoleLogger
     {

MPF.Frontend/Drive.cs

@@ -1,6 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.IO;
-using System.Linq;
 #if NET462_OR_GREATER || NETCOREAPP
 using Microsoft.Management.Infrastructure;
 using Microsoft.Management.Infrastructure.Generic;
@@ -86,7 +86,11 @@ namespace MPF.Frontend
 
             // Sanitize a Windows-formatted long device path
             if (devicePath.StartsWith("\\\\.\\"))
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+                devicePath = devicePath["\\\\.\\".Length..];
+#else
                 devicePath = devicePath.Substring("\\\\.\\".Length);
+#endif
 
             // Create and validate the drive info object
             var driveInfo = new DriveInfo(devicePath);
@@ -136,26 +140,31 @@ namespace MPF.Frontend
         public static List<Drive> CreateListOfDrives(bool ignoreFixedDrives)
         {
             var drives = GetDriveList(ignoreFixedDrives);
-            drives = [.. drives.OrderBy(i => i == null ? "\0" : i.Name)];
-            return drives;
+            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"></param>
-        /// <returns></returns>
-        public (MediaType?, string?) GetMediaType(RedumpSystem? system)
+        /// <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, null);
+                    return MediaType.FloppyDisk;
                 case Frontend.InternalDriveType.HardDisk:
-                    return (MediaType.HardDisk, null);
+                    return MediaType.HardDisk;
                 case Frontend.InternalDriveType.Removable:
-                    return (MediaType.FlashDrive, null);
+                    return MediaType.FlashDrive;
             }
 
             // Some systems should default to certain media types
@@ -168,18 +177,18 @@ namespace MPF.Frontend
                 case RedumpSystem.SegaSaturn:
                 case RedumpSystem.SonyPlayStation:
                 case RedumpSystem.VideoCD:
-                    return (MediaType.CDROM, null);
+                    return MediaType.CDROM;
 
                 // DVD
                 case RedumpSystem.DVDAudio:
                 case RedumpSystem.DVDVideo:
                 case RedumpSystem.MicrosoftXbox:
                 case RedumpSystem.MicrosoftXbox360:
-                    return (MediaType.DVD, null);
+                    return MediaType.DVD;
 
                 // HD-DVD
                 case RedumpSystem.HDDVDVideo:
-                    return (MediaType.HDDVD, null);
+                    return MediaType.HDDVD;
 
                 // Blu-ray
                 case RedumpSystem.BDVideo:
@@ -188,34 +197,34 @@ namespace MPF.Frontend
                 case RedumpSystem.SonyPlayStation3:
                 case RedumpSystem.SonyPlayStation4:
                 case RedumpSystem.SonyPlayStation5:
-                    return (MediaType.BluRay, null);
+                    return MediaType.BluRay;
 
                 // GameCube
                 case RedumpSystem.NintendoGameCube:
-                    return (MediaType.NintendoGameCubeGameDisc, null);
+                    return MediaType.NintendoGameCubeGameDisc;
 
                 // Wii
                 case RedumpSystem.NintendoWii:
-                    return (MediaType.NintendoWiiOpticalDisc, null);
+                    return MediaType.NintendoWiiOpticalDisc;
 
                 // WiiU
                 case RedumpSystem.NintendoWiiU:
-                    return (MediaType.NintendoWiiUOpticalDisc, null);
+                    return MediaType.NintendoWiiUOpticalDisc;
 
                 // PSP
                 case RedumpSystem.SonyPlayStationPortable:
-                    return (MediaType.UMD, null);
+                    return MediaType.UMD;
             }
 
             // Handle optical media by size and filesystem
             if (TotalSize >= 0 && TotalSize <= 800_000_000 && (DriveFormat == "CDFS" || DriveFormat == "UDF"))
-                return (MediaType.CDROM, null);
+                return MediaType.CDROM;
             else if (TotalSize > 800_000_000 && TotalSize <= 8_540_000_000 && (DriveFormat == "CDFS" || DriveFormat == "UDF"))
-                return (MediaType.DVD, null);
+                return MediaType.DVD;
             else if (TotalSize > 8_540_000_000)
-                return (MediaType.BluRay, null);
+                return MediaType.BluRay;
 
-            return (null, "Could not determine media type!");
+            return null;
         }
 
         /// <summary>
@@ -223,7 +232,7 @@ namespace MPF.Frontend
         /// </summary>
         public void RefreshDrive()
         {
-            var driveInfo = DriveInfo.GetDrives().FirstOrDefault(d => d?.Name == Name);
+            var driveInfo = Array.Find(DriveInfo.GetDrives(), d => d?.Name == Name);
             PopulateFromDriveInfo(driveInfo);
         }
 
@@ -252,20 +261,18 @@ namespace MPF.Frontend
             // TODO: Reduce reliance on `DriveInfo`
             // https://github.com/aaru-dps/Aaru/blob/5164a154e2145941472f2ee0aeb2eff3338ecbb3/Aaru.Devices/Windows/ListDevices.cs#L66
 
-            // Create an output drive list
-            var drives = new List<Drive>();
+            // Create an output drive array
+            Drive[] drives = [];
 
             // Get all standard supported drive types
             try
             {
-                drives = DriveInfo.GetDrives()
-                    .Where(d => desiredDriveTypes.Contains(d.DriveType))
-                    .Select(d => Create(ToInternalDriveType(d.DriveType), d.Name) ?? new Drive())
-                    .ToList();
+                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;
+                return [.. drives];
             }
 
             // Find and update all floppy drives
@@ -282,7 +289,11 @@ namespace MPF.Frontend
                     if (mediaType != null && ((mediaType > 0 && mediaType < 11) || (mediaType > 12 && mediaType < 22)))
                     {
                         char devId = (properties["Caption"].Value as string ?? string.Empty)[0];
-                        drives.ForEach(d => { if (d?.Name != null && d.Name[0] == devId) { d.InternalDriveType = Frontend.InternalDriveType.Floppy; } });
+                        Array.ForEach(drives, d =>
+                        {
+                            if (d?.Name != null && d.Name[0] == devId)
+                                d.InternalDriveType = Frontend.InternalDriveType.Floppy;
+                        });
                     }
                 }
             }
@@ -292,7 +303,7 @@ namespace MPF.Frontend
             }
 #endif
 
-            return drives;
+            return [.. drives];
         }
 
         /// <summary>

MPF.Frontend/DumpEnvironment.cs

@@ -2,11 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.IO.Compression;
-using System.Linq;
 using System.Text;
-#if NET40
-using System.Threading;
-#endif
 using System.Threading.Tasks;
 using BinaryObjectScanner;
 using MPF.ExecutionContexts;
@@ -53,7 +49,7 @@ namespace MPF.Frontend
         /// <summary>
         /// Options object representing user-defined options
         /// </summary>
-        private readonly Frontend.Options _options;
+        private readonly Options _options;
 
         /// <summary>
         /// Processor object representing how to process the outputs
@@ -65,11 +61,6 @@ namespace MPF.Frontend
         /// </summary>
         private readonly RedumpSystem? _system;
 
-        /// <summary>
-        /// Currently selected media type
-        /// </summary>
-        private readonly MediaType? _type;
-
         #endregion
 
         #region Passthrough Fields
@@ -90,11 +81,7 @@ namespace MPF.Frontend
         public int? Speed
         {
             get => _executionContext?.Speed;
-            set
-            {
-                if (_executionContext != null)
-                    _executionContext.Speed = value;
-            }
+            set => _executionContext?.Speed = value;
         }
 
         /// <inheritdoc cref="Extensions.LongName(RedumpSystem?)/>
@@ -118,16 +105,12 @@ namespace MPF.Frontend
         /// <param name="outputPath"></param>
         /// <param name="drive"></param>
         /// <param name="system"></param>
-        /// <param name="type"></param>
         /// <param name="internalProgram"></param>
-        /// <param name="parameters"></param>
-        public DumpEnvironment(Frontend.Options options,
+        public DumpEnvironment(Options options,
             string? outputPath,
             Drive? drive,
             RedumpSystem? system,
-            MediaType? type,
-            InternalProgram? internalProgram,
-            string? parameters)
+            InternalProgram? internalProgram)
         {
             // Set options object
             _options = options;
@@ -138,12 +121,7 @@ namespace MPF.Frontend
             // UI information
             _drive = drive;
             _system = system ?? options.DefaultSystem;
-            _type = type ?? MediaType.NONE;
             _internalProgram = internalProgram ?? options.InternalProgram;
-
-            // Dumping program
-            SetExecutionContext(parameters);
-            SetProcessor();
         }
 
         #region Internal Program Management
@@ -151,31 +129,60 @@ namespace MPF.Frontend
         /// <summary>
         /// Check output path for matching logs from all dumping programs
         /// </summary>
-        public InternalProgram? CheckForMatchingProgram(string? outputDirectory, string outputFilename)
+        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.Aaru)
+            if (programFound == null && _internalProgram != InternalProgram.Redumper)
             {
-                var processor = new Processors.Aaru(_system, _type);
-                (bool foundOtherFiles, _) = processor.FoundAllFiles(outputDirectory, outputFilename);
-                if (foundOtherFiles)
-                    programFound = InternalProgram.Aaru;
+                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, _type);
-                (bool foundOtherFiles, _) = processor.FoundAllFiles(outputDirectory, outputFilename);
-                if (foundOtherFiles)
+                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, _type);
-                (bool foundOtherFiles, _) = processor.FoundAllFiles(outputDirectory, outputFilename);
-                if (foundOtherFiles)
+                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;
         }
@@ -183,8 +190,9 @@ namespace MPF.Frontend
         /// <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(string? parameters)
+        public bool SetExecutionContext(MediaType? mediaType, string? parameters)
         {
             _executionContext = _internalProgram switch
             {
@@ -200,8 +208,8 @@ namespace MPF.Frontend
             // Set system, type, and drive
             if (_executionContext != null)
             {
-                _executionContext.System = _system;
-                _executionContext.Type = _type;
+                _executionContext.RedumpSystem = _system;
+                _executionContext.MediaType = mediaType;
 
                 // Set some parameters, if not already set
                 OutputPath ??= _executionContext.OutputPath!;
@@ -218,13 +226,13 @@ namespace MPF.Frontend
         {
             _processor = _internalProgram switch
             {
-                InternalProgram.Aaru => new Processors.Aaru(_system, _type),
-                InternalProgram.CleanRip => new CleanRip(_system, _type),
-                InternalProgram.DiscImageCreator => new DiscImageCreator(_system, _type),
-                InternalProgram.PS3CFW => new PS3CFW(_system, _type),
-                InternalProgram.Redumper => new Redumper(_system, _type),
-                InternalProgram.UmdImageCreator => new UmdImageCreator(_system, _type),
-                InternalProgram.XboxBackupCreator => new XboxBackupCreator(_system, _type),
+                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,
@@ -237,12 +245,13 @@ namespace MPF.Frontend
         /// <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(int? driveSpeed)
+        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 && _type != MediaType.NONE)
+            if (_system != null && mediaType != MediaType.NONE)
             {
                 // If drive letter is invalid, skip this
                 if (_drive == null)
@@ -251,9 +260,9 @@ namespace MPF.Frontend
                 // Set the proper parameters
                 _executionContext = _internalProgram switch
                 {
-                    InternalProgram.Aaru => new ExecutionContexts.Aaru.ExecutionContext(_system, _type, _drive.Name, OutputPath, driveSpeed, _options.Settings),
-                    InternalProgram.DiscImageCreator => new ExecutionContexts.DiscImageCreator.ExecutionContext(_system, _type, _drive.Name, OutputPath, driveSpeed, _options.Settings),
-                    InternalProgram.Redumper => new ExecutionContexts.Redumper.ExecutionContext(_system, _type, _drive.Name, OutputPath, driveSpeed, _options.Settings),
+                    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,
@@ -279,9 +288,9 @@ namespace MPF.Frontend
         /// </summary>
         /// <param name="type">MediaType value to check</param>
         /// <returns>True if the media has variable dumping speeds, false otherwise</returns>
-        public bool DoesSupportDriveSpeed()
+        public static bool DoesSupportDriveSpeed(MediaType? mediaType)
         {
-            return _type switch
+            return mediaType switch
             {
                 MediaType.CDROM
                     or MediaType.DVD
@@ -289,18 +298,28 @@ namespace MPF.Frontend
                     or MediaType.HDDVD
                     or MediaType.BluRay
                     or MediaType.NintendoGameCubeGameDisc
-                    or MediaType.NintendoWiiOpticalDisc => true,
+                    or MediaType.NintendoWiiOpticalDisc
+                    or MediaType.NintendoWiiUOpticalDisc => true,
                 _ => false,
             };
         }
 
-        /// <inheritdoc cref="BaseProcessor.FoundAllFiles(string?, string)"/>
-        public bool FoundAllFiles(string? outputDirectory, string outputFilename)
+        /// <inheritdoc cref="BaseProcessor.FoundAllFiles(MediaType?, string?, string)"/>
+        public bool FoundAllFiles(MediaType? mediaType, string? outputDirectory, string outputFilename)
         {
             if (_processor == null)
                 return false;
 
-            return _processor.FoundAllFiles(outputDirectory, outputFilename).Item1;
+            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?)"/>
@@ -324,15 +343,18 @@ namespace MPF.Frontend
         /// <summary>
         /// Verify that, given a system and a media type, they are correct
         /// </summary>
-        public ResultEventArgs GetSupportStatus()
+        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 _type switch
+            return mediaType switch
             {
+                // Null means it will be handled by the program
+                null => ResultEventArgs.Success("Ready to dump"),
+
                 // Fully supported types
                 MediaType.BluRay
                     or MediaType.CDROM
@@ -342,21 +364,22 @@ namespace MPF.Frontend
                     or MediaType.CompactFlash
                     or MediaType.SDCard
                     or MediaType.FlashDrive
-                    or MediaType.HDDVD => ResultEventArgs.Success($"{_type.LongName()} ready to dump"),
+                    or MediaType.HDDVD => ResultEventArgs.Success($"{mediaType.LongName()} ready to dump"),
 
                 // Partially supported types
                 MediaType.GDROM
                     or MediaType.NintendoGameCubeGameDisc
-                    or MediaType.NintendoWiiOpticalDisc => ResultEventArgs.Success($"{_type.LongName()} partially supported for dumping"),
+                    or MediaType.NintendoWiiOpticalDisc
+                    or MediaType.NintendoWiiUOpticalDisc => ResultEventArgs.Success($"{mediaType.LongName()} partially supported for dumping"),
 
                 // Special case for other supported tools
-                MediaType.UMD => ResultEventArgs.Failure($"{_type.LongName()} supported for submission info parsing"),
+                MediaType.UMD => ResultEventArgs.Failure($"{mediaType.LongName()} supported for submission info parsing"),
 
                 // Specifically unknown type
-                MediaType.NONE => ResultEventArgs.Failure($"Please select a valid media type"),
+                MediaType.NONE => ResultEventArgs.Failure("Please select a valid media type"),
 
                 // Undumpable but recognized types
-                _ => ResultEventArgs.Failure($"{_type.LongName()} media are not supported for dumping"),
+                _ => ResultEventArgs.Failure($"{mediaType.LongName()} media are not supported for dumping"),
             };
         }
 
@@ -384,15 +407,24 @@ namespace MPF.Frontend
         /// <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(IProgress<ResultEventArgs>? progress = null)
+        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();
+            ResultEventArgs result = IsValidForDump(mediaType);
             if (!result)
                 return result;
 
@@ -424,144 +456,175 @@ namespace MPF.Frontend
         public async Task<ResultEventArgs> VerifyAndSaveDumpOutput(
             IProgress<ResultEventArgs>? resultProgress = null,
             IProgress<ProtectionProgress>? protectionProgress = null,
-            Func<SubmissionInfo?, (bool?, SubmissionInfo?)>? processUserInfo = null,
+            ProcessUserInfoDelegate? processUserInfo = null,
             SubmissionInfo? seedInfo = null)
         {
             if (_processor == null)
                 return ResultEventArgs.Failure("Error! Current configuration is not supported!");
 
-            resultProgress?.Report(ResultEventArgs.Success("Gathering submission information... please wait!"));
+            // 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);
 
-            // Check to make sure that the output had all the correct files
-            (bool foundFiles, List<string> missingFiles) = _processor.FoundAllFiles(outputDirectory, outputFilename);
-            if (!foundFiles)
+            // If a standard log zip was provided, replace the suffix with ".tmp" for easier processing
+            if (outputFilename.EndsWith("_logs.zip", StringComparison.OrdinalIgnoreCase))
             {
-                resultProgress?.Report(ResultEventArgs.Failure($"There were files missing from the output:\n{string.Join("\n", [.. missingFiles])}"));
-                return ResultEventArgs.Failure("Error! Please check output directory as dump may be incomplete!");
+                int zipSuffixIndex = outputFilename.LastIndexOf("_logs.zip", StringComparison.OrdinalIgnoreCase);
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+                outputFilename = outputFilename[..zipSuffixIndex] + ".tmp";
+#else
+                outputFilename = outputFilename.Substring(0, zipSuffixIndex) + ".tmp";
+#endif
             }
 
+            // Determine the media type from the processor
+            MediaType? mediaType = _processor.DetermineMediaType(outputDirectory, outputFilename);
+            if (mediaType == null)
+                return ResultEventArgs.Failure("Could not determine the media type from output files...");
+
             // Extract the information from the output files
-            resultProgress?.Report(ResultEventArgs.Success("Extracting output information from output files..."));
+            resultProgress.Report(ResultEventArgs.Success("Extracting output information from output files..."));
             var submissionInfo = await SubmissionGenerator.ExtractOutputInformation(
                 OutputPath,
                 _drive,
                 _system,
-                _type,
+                mediaType,
                 _options,
                 _processor,
                 resultProgress,
                 protectionProgress);
-            resultProgress?.Report(ResultEventArgs.Success("Extracting information complete!"));
+            if (submissionInfo == null)
+                return ResultEventArgs.Failure("There was an issue extracting information!");
+            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..."));
-                Builder.InjectSubmissionInformation(submissionInfo, seedInfo);
-                resultProgress?.Report(ResultEventArgs.Success("Information injection complete!"));
+                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 confugured to
+            // Get user-modifiable information if configured to
             if (_options.PromptForDiscInformation && processUserInfo != null)
             {
-                resultProgress?.Report(ResultEventArgs.Success("Waiting for additional disc information..."));
-
-                bool? filledInfo;
-                (filledInfo, submissionInfo) = processUserInfo(submissionInfo);
-
+                resultProgress.Report(ResultEventArgs.Success("Waiting for additional media information..."));
+                bool? filledInfo = processUserInfo.Invoke(_options, ref submissionInfo);
                 if (filledInfo == true)
-                    resultProgress?.Report(ResultEventArgs.Success("Additional disc information added!"));
+                    resultProgress.Report(ResultEventArgs.Success("Additional media information added!"));
                 else
-                    resultProgress?.Report(ResultEventArgs.Success("Disc information skipped!"));
+                    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!"));
+            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, var formatResult) = Formatter.FormatOutputData(submissionInfo, _options.EnableRedumpCompatibility);
+            resultProgress.Report(ResultEventArgs.Success("Formatting information..."));
+            var formattedValues = Formatter.FormatOutputData(submissionInfo, _options.EnableRedumpCompatibility, out string? formatResult);
             if (formattedValues == null)
-                resultProgress?.Report(ResultEventArgs.Failure(formatResult));
+                resultProgress.Report(ResultEventArgs.Failure(formatResult));
             else
-                resultProgress?.Report(ResultEventArgs.Success(formatResult));
+                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, string txtResult) = WriteOutputData(outputDirectory, filenameSuffix, formattedValues);
+            resultProgress.Report(ResultEventArgs.Success("Writing submission information file..."));
+            bool txtSuccess = WriteOutputData(outputDirectory, filenameSuffix, formattedValues, out string txtResult);
             if (txtSuccess)
-                resultProgress?.Report(ResultEventArgs.Success(txtResult));
+                resultProgress.Report(ResultEventArgs.Success(txtResult));
             else
-                resultProgress?.Report(ResultEventArgs.Failure(txtResult));
+                resultProgress.Report(ResultEventArgs.Failure(txtResult));
 
             // Write the copy protection output
-            if (submissionInfo?.CopyProtection?.FullProtections != null && submissionInfo.CopyProtection.FullProtections.Any())
+            if (submissionInfo?.CopyProtection?.FullProtections != null && submissionInfo.CopyProtection.FullProtections.Count > 0)
             {
                 if (_options.ScanForProtection)
                 {
-                    resultProgress?.Report(ResultEventArgs.Success("Writing protection information file..."));
+                    resultProgress.Report(ResultEventArgs.Success("Writing protection information file..."));
                     bool scanSuccess = WriteProtectionData(outputDirectory, filenameSuffix, submissionInfo, _options.HideDriveLetters);
                     if (scanSuccess)
-                        resultProgress?.Report(ResultEventArgs.Success("Writing complete!"));
+                        resultProgress.Report(ResultEventArgs.Success("Writing complete!"));
                     else
-                        resultProgress?.Report(ResultEventArgs.Failure("Writing could not complete!"));
+                        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)}..."));
+                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!"));
+                    resultProgress.Report(ResultEventArgs.Success("Writing complete!"));
                 else
-                    resultProgress?.Report(ResultEventArgs.Failure("Writing could not complete!"));
+                    resultProgress.Report(ResultEventArgs.Failure("Writing could not complete!"));
             }
 
             // Compress the logs, if required
             if (_options.CompressLogFiles)
             {
-                resultProgress?.Report(ResultEventArgs.Success("Compressing log files..."));
-                (bool compressSuccess, string compressResult) = _processor?.CompressLogFiles(outputDirectory, filenameSuffix, outputFilename) ?? (false, "No processor provided!");
-                if (compressSuccess)
-                    resultProgress?.Report(ResultEventArgs.Success(compressResult));
-                else
-                    resultProgress?.Report(ResultEventArgs.Failure(compressResult));
+                resultProgress.Report(ResultEventArgs.Success("Compressing log files..."));
+#if NET40
+                await Task.Factory.StartNew(() =>
+#else
+                await Task.Run(() =>
+#endif
+                {
+                    bool compressSuccess = _processor.CompressLogFiles(mediaType, _options.LogCompression, 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, string deleteResult) = _processor?.DeleteUnnecessaryFiles(outputDirectory, outputFilename) ?? (false, "No processor provided!");
+                resultProgress.Report(ResultEventArgs.Success("Deleting unnecessary files..."));
+                bool deleteSuccess = _processor.DeleteUnnecessaryFiles(mediaType, outputDirectory, outputFilename, out string deleteResult);
                 if (deleteSuccess)
-                    resultProgress?.Report(ResultEventArgs.Success(deleteResult));
+                    resultProgress.Report(ResultEventArgs.Success(deleteResult));
                 else
-                    resultProgress?.Report(ResultEventArgs.Failure(deleteResult));
+                    resultProgress.Report(ResultEventArgs.Failure(deleteResult));
             }
 
             // Create PS3 IRD, if required
-            if (_options.CreateIRDAfterDumping && _system == RedumpSystem.SonyPlayStation3 && _type == MediaType.BluRay)
+            if (_options.CreateIRDAfterDumping && _system == RedumpSystem.SonyPlayStation3 && mediaType == MediaType.BluRay)
             {
-                resultProgress?.Report(ResultEventArgs.Success("Creating IRD... please wait!"));
-                (bool deleteSuccess, string deleteResult) = await WriteIRD(OutputPath, submissionInfo?.Extras?.DiscKey, submissionInfo?.Extras?.DiscID, submissionInfo?.Extras?.PIC, submissionInfo?.SizeAndChecksums?.Layerbreak, submissionInfo?.SizeAndChecksums?.CRC32);
+                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(deleteResult));
+                    resultProgress.Report(ResultEventArgs.Success("IRD created!"));
                 else
-                    resultProgress?.Report(ResultEventArgs.Failure(deleteResult));
+                    resultProgress.Report(ResultEventArgs.Failure("Failed to create IRD"));
             }
 
-            resultProgress?.Report(ResultEventArgs.Success("Submission information process complete!"));
+            resultProgress.Report(ResultEventArgs.Success("Submission information process complete!"));
             return ResultEventArgs.Success();
         }
 
@@ -569,18 +632,18 @@ namespace MPF.Frontend
         /// Checks if the parameters are valid
         /// </summary>
         /// <returns>True if the configuration is valid, false otherwise</returns>
-        internal bool ParametersValid()
+        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 ^ _type == MediaType.FloppyDisk);
+            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)
-                ^ (_type == MediaType.CompactFlash || _type == MediaType.SDCard || _type == MediaType.FlashDrive || _type == MediaType.HardDisk));
+                ^ (mediaType == MediaType.CompactFlash || mediaType == MediaType.SDCard || mediaType == MediaType.FlashDrive || mediaType == MediaType.HardDisk));
 
             return parametersValid && floppyValid && removableDiskValid;
         }
@@ -589,10 +652,10 @@ namespace MPF.Frontend
         /// Validate the current environment is ready for a dump
         /// </summary>
         /// <returns>Result instance with the outcome</returns>
-        private ResultEventArgs IsValidForDump()
+        private ResultEventArgs IsValidForDump(MediaType? mediaType)
         {
             // Validate that everything is good
-            if (_executionContext == null || !ParametersValid())
+            if (_executionContext == null || !ParametersValid(mediaType))
                 return ResultEventArgs.Failure("Error! Current configuration is not supported!");
 
             // Fix the output paths, just in case
@@ -612,7 +675,7 @@ namespace MPF.Frontend
                 return ResultEventArgs.Failure("Error! Cannot dump same drive that executable resides on!");
 
             // Validate that the current configuration is supported
-            return GetSupportStatus();
+            return GetSupportStatus(mediaType);
         }
 
         #endregion
@@ -622,15 +685,18 @@ namespace MPF.Frontend
         /// <summary>
         /// Write the data to the output folder
         /// </summary>
-        /// <param name="outputDirectory">Output folder to write to</param>
+        /// <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 list of lines to write out to the file</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, string) WriteOutputData(string? outputDirectory, string? filenameSuffix, List<string>? lines)
+        private static bool WriteOutputData(string? outputDirectory, string? filenameSuffix, string? lines, out string status)
         {
             // Check to see if the inputs are valid
             if (lines == null)
-                return (false, "No formatted data found to write!");
+            {
+                status = "No formatted data found to write!";
+                return false;
+            }
 
             // Now write out to a generic file
             try
@@ -647,24 +713,23 @@ namespace MPF.Frontend
                     path = Path.Combine(outputDirectory, $"!submissionInfo_{filenameSuffix}.txt");
 
                 using var sw = new StreamWriter(File.Open(path, FileMode.Create, FileAccess.Write), Encoding.UTF8);
-                foreach (string line in lines)
-                {
-                    sw.WriteLine(line);
-                }
+                sw.Write(lines);
             }
             catch (Exception ex)
             {
-                return (false, $"Writing could not complete: {ex}");
+                status = $"Writing could not complete: {ex}";
+                return false;
             }
 
-            return (true, "Writing complete!");
+            status = "Writing complete!";
+            return true;
         }
 
         // MOVE TO REDUMPLIB
         /// <summary>
         /// Write the data to the output folder
         /// </summary>
-        /// <param name="outputDirectory">Output folder to write to</param>
+        /// <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>
@@ -677,48 +742,43 @@ namespace MPF.Frontend
 
             try
             {
-                // Serialize the JSON and get it writable
-                string json = JsonConvert.SerializeObject(info, Formatting.Indented);
-                byte[] jsonBytes = Encoding.UTF8.GetBytes(json);
+                // 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)
                 {
-                    var path = string.Empty;
-                    if (string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
-                        path = "!submissionInfo.json.gz";
-                    else if (string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
-                        path = $"!submissionInfo_{filenameSuffix}.json.gz";
-                    else if (!string.IsNullOrEmpty(outputDirectory) && string.IsNullOrEmpty(filenameSuffix))
-                        path = Path.Combine(outputDirectory, "!submissionInfo.json.gz");
-                    else if (!string.IsNullOrEmpty(outputDirectory) && !string.IsNullOrEmpty(filenameSuffix))
-                        path = Path.Combine(outputDirectory, $"!submissionInfo_{filenameSuffix}.json.gz");
-
-                    using var fs = File.Create(path);
                     using var gs = new GZipStream(fs, CompressionMode.Compress);
-                    gs.Write(jsonBytes, 0, jsonBytes.Length);
+                    using var sw = new StreamWriter(gs, Encoding.UTF8);
+                    serializer.Serialize(sw, info);
                 }
-
-                // Otherwise, write out to a normal JSON
                 else
                 {
-                    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");
-
-                    using var fs = File.Create(path);
-                    fs.Write(jsonBytes, 0, jsonBytes.Length);
+                    using var sw = new StreamWriter(fs, Encoding.UTF8);
+                    serializer.Serialize(sw, info);
                 }
             }
             catch
             {
-                // We don't care what the error is right now
+                // Absorb the exception
                 return false;
             }
 
@@ -729,7 +789,7 @@ namespace MPF.Frontend
         /// <summary>
         /// Write the protection data to the output folder
         /// </summary>
-        /// <param name="outputDirectory">Output folder to write to</param>
+        /// <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>
@@ -737,7 +797,7 @@ namespace MPF.Frontend
         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.Any())
+            if (info?.CopyProtection?.FullProtections == null || info.CopyProtection.FullProtections.Count == 0)
                 return true;
 
             // Now write out to a generic file
@@ -755,12 +815,18 @@ namespace MPF.Frontend
 
                 using var sw = new StreamWriter(File.Open(path, FileMode.Create, FileAccess.Write), Encoding.UTF8);
 
-                List<string> sortedKeys = [.. info.CopyProtection.FullProtections.Keys.OrderBy(k => k)];
+                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);
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+                        scanPath = Path.DirectorySeparatorChar + key[(Path.GetPathRoot(key) ?? string.Empty).Length..];
+#else
+                        scanPath = Path.DirectorySeparatorChar + key.Substring((Path.GetPathRoot(key) ?? string.Empty).Length);
+#endif
 
                     List<string>? scanResult = info.CopyProtection.FullProtections[key];
 
@@ -772,68 +838,13 @@ namespace MPF.Frontend
             }
             catch
             {
-                // We don't care what the error is right now
+                // Absorb the exception
                 return false;
             }
 
             return true;
         }
 
-        /// <summary>
-        /// Create an IRD and write it to the specified output directory with optional filename suffix
-        /// </summary>
-        /// <param name="outputDirectory">Output folder to write to</param>
-        /// <param name="filenameSuffix">Optional suffix to append to the filename</param>
-        /// <param name="outputFilename">Output filename to use as the base path</param>
-        /// <returns>True on success, false on error</returns>
-        private static async Task<(bool, string)> WriteIRD(string isoPath, string? discKeyString, string? discIDString, string? picString, long? layerbreak, string? crc32)
-        {
-            try
-            {
-                // Output IRD file path
-                string irdPath = Path.ChangeExtension(isoPath, ".ird");
-
-                // Parse disc key from submission info (Required)
-                byte[]? discKey = ProcessingTool.ParseHexKey(discKeyString);
-                if (discKey == null)
-                    return (false, "Failed to create IRD: No key provided");
-
-                // Parse Disc ID from submission info (Optional)
-                byte[]? discID = ProcessingTool.ParseDiscID(discIDString);
-
-                // Parse PIC from submission info (Optional)
-                byte[]? pic = ProcessingTool.ParsePIC(picString);
-
-                // Parse CRC32 strings into ISO hash for Unique ID field (Optional)
-                uint? uid = ProcessingTool.ParseCRC32(crc32);
-
-                // Ensure layerbreak value is valid (Optional)
-                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));
-                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, "IRD created!");
-            }
-            catch (Exception)
-            {
-                // We don't care what the error is
-                return (false, "Failed to create IRD");
-            }
-        }
-
         #endregion
     }
 }

MPF.Frontend/EnumExtensions.cs

@@ -6,6 +6,8 @@ using System.Collections.Concurrent;
 #endif
 using System.Reflection;
 using SabreTools.RedumpLib.Data;
+using LogCompression = MPF.Processors.LogCompression;
+using RedumperDriveType = MPF.ExecutionContexts.Redumper.DriveType;
 using RedumperReadMethod = MPF.ExecutionContexts.Redumper.ReadMethod;
 using RedumperSectorOrder = MPF.ExecutionContexts.Redumper.SectorOrder;
 
@@ -49,7 +51,7 @@ namespace MPF.Frontend
                 }
 
                 if (method != null)
-                    return method.Invoke(null, new[] { value }) as string ?? string.Empty;
+                    return method.Invoke(null, [value]) as string ?? string.Empty;
                 else
                     return string.Empty;
             }
@@ -60,6 +62,49 @@ namespace MPF.Frontend
             }
         }
 
+        /// <summary>
+        /// Get the string representation of the InterfaceLanguage enum values
+        /// </summary>
+        /// <param name="lang">InterfaceLanguage value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this InterfaceLanguage lang)
+            => ((InterfaceLanguage?)lang).LongName();
+
+        /// <summary>
+        /// Get the string representation of the InterfaceLanguage enum values
+        /// </summary>
+        /// <param name="lang">InterfaceLanguage value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this InterfaceLanguage? lang)
+        {
+            return lang switch
+            {
+                InterfaceLanguage.AutoDetect => "Auto Detect",
+                InterfaceLanguage.English => "English",
+                InterfaceLanguage.French => "Français",
+                InterfaceLanguage.German => "Deutsch",
+                InterfaceLanguage.Italian => "Italiano",
+                InterfaceLanguage.Japanese => "日本語",
+                InterfaceLanguage.Korean => "한국어",
+                InterfaceLanguage.Polish => "Polski",
+                InterfaceLanguage.Russian => "Русский",
+                InterfaceLanguage.Spanish => "Español",
+                InterfaceLanguage.Swedish => "Svenska",
+                InterfaceLanguage.Ukrainian => "Українська",
+                InterfaceLanguage.L337 => "L337",
+
+                _ => "Unknown",
+            };
+        }
+
+        /// <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)
+            => ((InternalProgram?)prog).LongName();
+
         /// <summary>
         /// Get the string representation of the InternalProgram enum values
         /// </summary>
@@ -67,7 +112,7 @@ namespace MPF.Frontend
         /// <returns>String representing the value, if possible</returns>
         public static string LongName(this InternalProgram? prog)
         {
-            return (prog) switch
+            return prog switch
             {
                 #region Dumping support
 
@@ -91,6 +136,39 @@ namespace MPF.Frontend
             };
         }
 
+        /// <summary>
+        /// Get the string representation of the LogCompression enum values
+        /// </summary>
+        /// <param name="comp">LogCompression value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this LogCompression comp)
+            => ((LogCompression?)comp).LongName();
+
+        /// <summary>
+        /// Get the string representation of the LogCompression enum values
+        /// </summary>
+        /// <param name="comp">LogCompression value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this LogCompression? comp)
+        {
+            return comp switch
+            {
+                LogCompression.DeflateDefault => "ZIP using Deflate (Level 5)",
+                LogCompression.DeflateMaximum => "ZIP using Deflate (Level 9)",
+                LogCompression.Zstd19 => "ZIP using Zstd (Level 19)",
+
+                _ => "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)
+            => ((RedumperReadMethod?)method).LongName();
+
         /// <summary>
         /// Get the string representation of the RedumperReadMethod enum values
         /// </summary>
@@ -98,17 +176,24 @@ namespace MPF.Frontend
         /// <returns>String representing the value, if possible</returns>
         public static string LongName(this RedumperReadMethod? method)
         {
-            return (method) switch
+            return method switch
             {
                 RedumperReadMethod.D8 => "D8",
                 RedumperReadMethod.BE => "BE",
-                RedumperReadMethod.BE_CDDA => "BE_CDDA",
 
                 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)
+            => ((RedumperSectorOrder?)order).LongName();
+
         /// <summary>
         /// Get the string representation of the RedumperSectorOrder enum values
         /// </summary>
@@ -116,7 +201,7 @@ namespace MPF.Frontend
         /// <returns>String representing the value, if possible</returns>
         public static string LongName(this RedumperSectorOrder? order)
         {
-            return (order) switch
+            return order switch
             {
                 RedumperSectorOrder.DATA_C2_SUB => "DATA_C2_SUB",
                 RedumperSectorOrder.DATA_SUB_C2 => "DATA_SUB_C2",
@@ -128,10 +213,202 @@ namespace MPF.Frontend
             };
         }
 
+        /// <summary>
+        /// Get the string representation of the RedumperDriveType enum values
+        /// </summary>
+        /// <param name="type">RedumperDriveType value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string LongName(this RedumperDriveType type)
+            => ((RedumperDriveType?)type).LongName();
+
+        /// <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 InterfaceLanguage enum values
+        /// </summary>
+        /// <param name="lang">InterfaceLanguage value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string ShortName(this InterfaceLanguage lang)
+            => ((InterfaceLanguage?)lang).ShortName();
+
+        /// <summary>
+        /// Get the short string representation of the InterfaceLanguage enum values
+        /// </summary>
+        /// <param name="lang">InterfaceLanguage value to convert</param>
+        /// <returns>String representing the value, if possible</returns>
+        public static string ShortName(this InterfaceLanguage? lang)
+        {
+            return lang switch
+            {
+                InterfaceLanguage.AutoDetect => "auto",
+                InterfaceLanguage.English => "eng",
+                InterfaceLanguage.French => "fra",
+                InterfaceLanguage.German => "deu",
+                InterfaceLanguage.Italian => "ita",
+                InterfaceLanguage.Japanese => "jpn",
+                InterfaceLanguage.Korean => "kor",
+                InterfaceLanguage.Polish => "pol",
+                InterfaceLanguage.Russian => "rus",
+                InterfaceLanguage.Spanish => "spa",
+                InterfaceLanguage.Swedish => "swe",
+                InterfaceLanguage.Ukrainian => "ukr",
+                InterfaceLanguage.L337 => "l37",
+
+                _ => "Unknown",
+            };
+        }
+
+        /// <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 InterfaceLanguage enum value for a given string
+        /// </summary>
+        /// <param name="internalLanguage">String value to convert</param>
+        /// <returns>InterfaceLanguage represented by the string, if possible</returns>
+        public static InterfaceLanguage ToInterfaceLanguage(this string? internalLanguage)
+        {
+            return (internalLanguage?.ToLowerInvariant()) switch
+            {
+                "auto" or "autodetect" or "auto detect" => InterfaceLanguage.AutoDetect,
+                "eng" or "english" => InterfaceLanguage.English,
+                "fra" or "french" or "français" => InterfaceLanguage.French,
+                "deu" or "german" or "deutsch" => InterfaceLanguage.German,
+                "ita" or "italian" or "italiano" => InterfaceLanguage.Italian,
+                "jpn" or "japanese" or "日本語" => InterfaceLanguage.Japanese,
+                "kor" or "korean" or "한국어" => InterfaceLanguage.Korean,
+                "pol" or "polish" or "polski" => InterfaceLanguage.Polish,
+                "rus" or "russian" or "русский" => InterfaceLanguage.Russian,
+                "spa" or "spanish" or "español" => InterfaceLanguage.Spanish,
+                "swe" or "swedish" or "svenska" => InterfaceLanguage.Swedish,
+                "ukr" or "ukranian" or "українська" => InterfaceLanguage.Ukrainian,
+                "l37" or "l337" => InterfaceLanguage.L337,
+
+                _ => InterfaceLanguage.AutoDetect,
+            };
+        }
+
+        /// <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 LogCompression enum value for a given string
+        /// </summary>
+        /// <param name="logCompression">String value to convert</param>
+        /// <returns>LogCompression represented by the string, if possible</returns>
+        public static LogCompression ToLogCompression(this string? logCompression)
+        {
+            return (logCompression?.ToLowerInvariant()) switch
+            {
+                "deflate"
+                    or "deflatedefault"
+                    or "zip" => LogCompression.DeflateDefault,
+                "deflatemaximum"
+                    or "max"
+                    or "maximum" => LogCompression.DeflateMaximum,
+                "zstd"
+                    or "zstd19" => LogCompression.Zstd19,
+
+                _ => LogCompression.DeflateDefault,
+            };
+        }
+
         /// <summary>
         /// Get the RedumperReadMethod enum value for a given string
         /// </summary>
@@ -143,10 +420,6 @@ namespace MPF.Frontend
             {
                 "d8" => RedumperReadMethod.D8,
                 "be" => RedumperReadMethod.BE,
-                "be_cdda"
-                    or "be cdda"
-                    or "be-cdda"
-                    or "becdda" => RedumperReadMethod.BE_CDDA,
 
                 _ => RedumperReadMethod.NONE,
             };
@@ -182,6 +455,47 @@ namespace MPF.Frontend
             };
         }
 
+        /// <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_asu8a"
+                    or "lg-asu8a"
+                    or "lgasu8a"
+                    or "lg_asu_8a"
+                    or "lg-asu-8a" => RedumperDriveType.LG_ASU8A,
+                "lg_asu8b"
+                    or "lg-asu8b"
+                    or "lgasu8b"
+                    or "lg_asu_8b"
+                    or "lg-asu-8b" => RedumperDriveType.LG_ASU8B,
+                "lg_asu8c"
+                    or "lg-asu8c"
+                    or "lgasu8c"
+                    or "lg_asu_8c"
+                    or "lg-asu-8c" => RedumperDriveType.LG_ASU8C,
+                "lg_asus3"
+                    or "lg-asu3"
+                    or "lgasu3"
+                    or "lg_asu_3"
+                    or "lg-asu-3" => RedumperDriveType.LG_ASU3,
+                "lg_asu2"
+                    or "lg-asu2"
+                    or "lgasu2"
+                    or "lg_asu_2"
+                    or "lg-asu-2" => RedumperDriveType.LG_ASU2,
+
+                _ => RedumperDriveType.NONE,
+            };
+        }
+
         #endregion
 
         #region Functionality Support
@@ -206,6 +520,7 @@ namespace MPF.Frontend
             return system switch
             {
                 RedumpSystem.AppleMacintosh => true,
+                RedumpSystem.DVDVideo => true,
                 RedumpSystem.EnhancedCD => true,
                 RedumpSystem.IBMPCcompatible => true,
                 RedumpSystem.PalmOS => true,

MPF.Frontend/Enumerations.cs

@@ -1,5 +1,32 @@
 namespace MPF.Frontend
 {
+    /// <summary>
+    /// Interface language
+    /// </summary>
+    public enum InterfaceLanguage
+    {
+        /// <summary>
+        /// Default to auto-detecting language
+        /// </summary>
+        AutoDetect = 0,
+
+        // Selectable languages (in Manual Window dropdown)
+        English,
+        French,
+        German,
+        Italian,
+        Japanese,
+        Korean,
+        Polish,
+        Russian,
+        Spanish,
+        Swedish,
+        Ukrainian,
+
+        // Hidden languages (not in Main Window dropdown)
+        L337,
+    }
+
     /// <summary>
     /// Drive type for dumping
     /// </summary>
@@ -40,4 +67,4 @@ namespace MPF.Frontend
         ERROR,
         SECRET,
     }
-}
+}

MPF.Frontend/Features/ListCodesFeature.cs

@@ -0,0 +1,38 @@
+using System;
+using SabreTools.CommandLine;
+
+namespace MPF.Frontend.Features
+{
+    public class ListCodesFeature : Feature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "listcodes";
+
+        private static readonly string[] _flags = ["lc", "listcodes"];
+
+        private const string _description = "List supported comment/content site codes";
+
+        #endregion
+
+        public ListCodesFeature()
+            : base(DisplayName, _flags, _description)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override bool Execute()
+        {
+            Console.WriteLine("Supported Site Codes:");
+            foreach (string siteCode in SabreTools.RedumpLib.Data.Extensions.ListSiteCodes())
+            {
+                Console.WriteLine(siteCode);
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => true;
+    }
+}

MPF.Frontend/Features/ListConfigFeature.cs

@@ -0,0 +1,150 @@
+using System;
+using MPF.Frontend;
+using MPF.Frontend.Tools;
+using SabreTools.RedumpLib.Data;
+
+namespace MPF.Frontend.Features
+{
+    public class ListConfigFeature : SabreTools.CommandLine.Feature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "listconfig";
+
+        private static readonly string[] _flags = ["lo", "listconfig"];
+
+        private const string _description = "List current configuration values";
+
+        #endregion
+
+        public ListConfigFeature()
+            : base(DisplayName, _flags, _description)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override bool Execute()
+        {
+            // Try to load the current config
+            var options = OptionsLoader.LoadFromConfig();
+            if (options.FirstRun)
+            {
+                Console.WriteLine("No valid configuration found!");
+                return true;
+            }
+
+            // Paths
+            Console.WriteLine("Paths:");
+            Console.WriteLine($"  Aaru Path = {options.AaruPath}");
+            Console.WriteLine($"  DiscImageCreator Path = {options.DiscImageCreatorPath}");
+            Console.WriteLine($"  Redumper Path = {options.RedumperPath}");
+            Console.WriteLine($"  Default Program = {options.InternalProgram.LongName()}");
+            Console.WriteLine();
+
+            // UI Defaults
+            Console.WriteLine("UI Defaults:");
+            Console.WriteLine($"  Dark Mode = {options.EnableDarkMode}");
+            Console.WriteLine($"  Purp Mode = {options.EnablePurpMode}");
+            Console.WriteLine($"  Custom Background Color = {options.CustomBackgroundColor}");
+            Console.WriteLine($"  Custom Text Color = {options.CustomTextColor}");
+            Console.WriteLine($"  Check for Updates on Startup = {options.CheckForUpdatesOnStartup}");
+            Console.WriteLine($"  Copy Update URL to Clipboard = {options.CopyUpdateUrlToClipboard}");
+            Console.WriteLine($"  Fast Label Update = {options.FastUpdateLabel}");
+            Console.WriteLine($"  Default Interface Language = {options.DefaultInterfaceLanguage.LongName()}");
+            Console.WriteLine($"  Default Output Path = {options.DefaultOutputPath}");
+            Console.WriteLine($"  Default System = {options.DefaultSystem.LongName()}");
+            Console.WriteLine($"  Show Debug Menu Item = {options.ShowDebugViewMenuItem}");
+            Console.WriteLine();
+
+            // Dumping Speeds
+            Console.WriteLine("Dumping Speeds:");
+            Console.WriteLine($"  Default CD Speed = {options.PreferredDumpSpeedCD}");
+            Console.WriteLine($"  Default DVD Speed = {options.PreferredDumpSpeedDVD}");
+            Console.WriteLine($"  Default HD-DVD Speed = {options.PreferredDumpSpeedHDDVD}");
+            Console.WriteLine($"  Default Blu-ray Speed = {options.PreferredDumpSpeedBD}");
+            Console.WriteLine();
+
+            // Aaru
+            Console.WriteLine("Aaru-Specific Options:");
+            Console.WriteLine($"  Enable Debug = {options.AaruEnableDebug}");
+            Console.WriteLine($"  Enable Verbose = {options.AaruEnableVerbose}");
+            Console.WriteLine($"  Force Dumping = {options.AaruForceDumping}");
+            Console.WriteLine($"  Reread Count = {options.AaruRereadCount}");
+            Console.WriteLine($"  Strip Personal Data = {options.AaruStripPersonalData}");
+            Console.WriteLine();
+
+            // DiscImageCreator
+            Console.WriteLine("DiscImageCreator-Specific Options:");
+            Console.WriteLine($"  Multi-Sector Read Flag = {options.DICMultiSectorRead}");
+            Console.WriteLine($"  Multi-Sector Read Value = {options.DICMultiSectorReadValue}");
+            Console.WriteLine($"  Overly-Secure Flags = {options.DICParanoidMode}");
+            Console.WriteLine($"  Quiet Flag = {options.DICQuietMode}");
+            Console.WriteLine($"  CD Reread Count = {options.DICRereadCount}");
+            Console.WriteLine($"  DVD Reread Count = {options.DICDVDRereadCount}");
+            Console.WriteLine($"  Use CMI Flag = {options.DICUseCMIFlag}");
+            Console.WriteLine();
+
+            // Redumper
+            Console.WriteLine("Redumper-Specific Options:");
+            Console.WriteLine($"  Enable Skeleton = {options.RedumperEnableSkeleton}");
+            Console.WriteLine($"  Enable Verbose = {options.RedumperEnableVerbose}");
+            Console.WriteLine($"  Lead-in Retry Count = {options.RedumperLeadinRetryCount}");
+            Console.WriteLine($"  Non-Redump Mode = {options.RedumperNonRedumpMode}");
+            Console.WriteLine($"  Drive Type = {options.RedumperDriveType.LongName()}");
+            Console.WriteLine($"  Read Method = {options.RedumperReadMethod.LongName()}");
+            Console.WriteLine($"  Sector Order = {options.RedumperSectorOrder.LongName()}");
+            Console.WriteLine($"  Reread Count = {options.RedumperRereadCount}");
+            Console.WriteLine($"  Refine Sector Mode = {options.RedumperRefineSectorMode}");
+            Console.WriteLine();
+
+            // Extra Dumping Options
+            Console.WriteLine("Extra Dumping Options:");
+            Console.WriteLine($"  Scan for Protection = {options.ScanForProtection}");
+            Console.WriteLine($"  Add Placeholders = {options.AddPlaceholders}");
+            Console.WriteLine($"  Prompt for Media Information = {options.PromptForDiscInformation}");
+            Console.WriteLine($"  Pull All Information = {options.PullAllInformation}");
+            Console.WriteLine($"  Enable Tabs in Input Fields = {options.EnableTabsInInputFields}");
+            Console.WriteLine($"  Enable Redump Compatibility = {options.EnableRedumpCompatibility}");
+            Console.WriteLine($"  Show Disc Eject Reminder = {options.ShowDiscEjectReminder}");
+            Console.WriteLine($"  Ignore Fixed Drives = {options.IgnoreFixedDrives}");
+            Console.WriteLine($"  Add Filename Suffix = {options.AddFilenameSuffix}");
+            Console.WriteLine($"  Output Submission JSON = {options.OutputSubmissionJSON}");
+            Console.WriteLine($"  Include Artifacts = {options.IncludeArtifacts}");
+            Console.WriteLine($"  Compress Log Files = {options.CompressLogFiles}");
+            Console.WriteLine($"  Log Compression = {options.LogCompression.LongName()}");
+            Console.WriteLine($"  Delete Unnecessary Files = {options.DeleteUnnecessaryFiles}");
+            Console.WriteLine($"  Create IRD After Dumping = {options.CreateIRDAfterDumping}");
+            Console.WriteLine();
+
+            // Skip Options
+            Console.WriteLine("Skip Options:");
+            Console.WriteLine($"  Skip System Detection = {options.SkipSystemDetection}");
+            Console.WriteLine();
+
+            // Protection Scanning Options
+            Console.WriteLine("Protection Scanning Options:");
+            Console.WriteLine($"  Scan Archives for Protection = {options.ScanArchivesForProtection}");
+            Console.WriteLine($"  Include Debug Protection Information = {options.IncludeDebugProtectionInformation}");
+            Console.WriteLine($"  Hide Drive Letters = {options.HideDriveLetters}");
+            Console.WriteLine();
+
+            // Logging Options
+            Console.WriteLine("Logging Options:");
+            Console.WriteLine($"  Verbose Logging = {options.VerboseLogging}");
+            Console.WriteLine($"  Open Log Window at Startup = {options.OpenLogWindowAtStartup}");
+            Console.WriteLine();
+
+            // Redump Login Information
+            Console.WriteLine("Redump Login Information:");
+            Console.WriteLine($"  Retrieve Match Information = {options.RetrieveMatchInformation}");
+            Console.WriteLine($"  Redump Username = {options.RedumpUsername}");
+            Console.WriteLine($"  Redump Password = {(string.IsNullOrEmpty(options.RedumpPassword) ? "[UNSET]" : "[SET]")}");
+            Console.WriteLine();
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => true;
+    }
+}

MPF.Frontend/Features/ListMediaTypesFeature.cs

@@ -0,0 +1,38 @@
+using System;
+using SabreTools.CommandLine;
+
+namespace MPF.Frontend.Features
+{
+    public class ListMediaTypesFeature : Feature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "listmedia";
+
+        private static readonly string[] _flags = ["lm", "listmedia"];
+
+        private const string _description = "List supported media types";
+
+        #endregion
+
+        public ListMediaTypesFeature()
+            : base(DisplayName, _flags, _description)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override bool Execute()
+        {
+            Console.WriteLine("Supported Media Types:");
+            foreach (string mediaType in SabreTools.RedumpLib.Data.Extensions.ListMediaTypes())
+            {
+                Console.WriteLine(mediaType);
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => true;
+    }
+}

MPF.Frontend/Features/ListProgramsFeature.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using SabreTools.CommandLine;
+
+namespace MPF.Frontend.Features
+{
+    public class ListProgramsFeature : Feature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "listprograms";
+
+        private static readonly string[] _flags = ["lp", "listprograms"];
+
+        private const string _description = "List supported dumping program outputs";
+
+        #endregion
+
+        public ListProgramsFeature()
+            : base(DisplayName, _flags, _description)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override bool Execute()
+        {
+            Console.WriteLine("Supported Programs:");
+            foreach (string program in ListPrograms())
+            {
+                Console.WriteLine(program);
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => true;
+
+        /// <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;
+        }
+    }
+}

MPF.Frontend/Features/ListSystemsFeature.cs

@@ -0,0 +1,38 @@
+using System;
+using SabreTools.CommandLine;
+
+namespace MPF.Frontend.Features
+{
+    public class ListSystemsFeature : Feature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "listsystems";
+
+        private static readonly string[] _flags = ["ls", "listsystems"];
+
+        private const string _description = "List supported system types";
+
+        #endregion
+
+        public ListSystemsFeature()
+            : base(DisplayName, _flags, _description)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override bool Execute()
+        {
+            Console.WriteLine("Supported Systems:");
+            foreach (string system in SabreTools.RedumpLib.Data.Extensions.ListSystems())
+            {
+                Console.WriteLine(system);
+            }
+
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => true;
+    }
+}

MPF.Frontend/Features/VersionFeature.cs

@@ -0,0 +1,34 @@
+using System;
+using MPF.Frontend.Tools;
+using SabreTools.CommandLine;
+
+namespace MPF.Frontend.Features
+{
+    public class VersionFeature : Feature
+    {
+        #region Feature Definition
+
+        public const string DisplayName = "version";
+
+        private static readonly string[] _flags = ["version"];
+
+        private const string _description = "Display the program version";
+
+        #endregion
+
+        public VersionFeature()
+            : base(DisplayName, _flags, _description)
+        {
+        }
+
+        /// <inheritdoc/>
+        public override bool Execute()
+        {
+            Console.WriteLine(FrontendTool.GetCurrentVersion() ?? "Unknown version");
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public override bool VerifyInputs() => true;
+    }
+}

MPF.Frontend/InterfaceConstants.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using System.Linq;
 using SabreTools.RedumpLib.Data;
 
 namespace MPF.Frontend
@@ -12,39 +11,34 @@ namespace MPF.Frontend
         /// <summary>
         /// Set of all accepted speed values
         /// </summary>
-        private static readonly List<int> _speedValues = [1, 2, 3, 4, 6, 8, 12, 16, 20, 24, 32, 40, 44, 48, 52, 56, 72];
+        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 IList<int> CD => _speedValues.Where(s => s <= 72).ToList();
+        public static List<int> CD => _speedValues.FindAll(s => s <= 72);
 
         /// <summary>
         /// Set of accepted speeds for DVD media
         /// </summary>
-        public static IList<int> DVD => _speedValues.Where(s => s <= 24).ToList();
+        public static List<int> DVD => _speedValues.FindAll(s => s <= 24);
 
         /// <summary>
         /// Set of accepted speeds for HD-DVD media
         /// </summary>
-        public static IList<int> HDDVD => _speedValues.Where(s => s <= 24).ToList();
+        public static List<int> HDDVD => _speedValues.FindAll(s => s <= 24);
 
         /// <summary>
         /// Set of accepted speeds for BD media
         /// </summary>
-        public static IList<int> BD => _speedValues.Where(s => s <= 16).ToList();
-
-        /// <summary>
-        /// Set of accepted speeds for all other media
-        /// </summary>
-        public static IList<int> Unknown => _speedValues.Where(s => s <= 1).ToList();
+        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 IList<int> GetSpeedsForMediaType(MediaType? type)
+        public static List<int> GetSpeedsForMediaType(MediaType? type)
         {
             return type switch
             {
@@ -54,8 +48,11 @@ namespace MPF.Frontend
                     or MediaType.NintendoGameCubeGameDisc
                     or MediaType.NintendoWiiOpticalDisc => DVD,
                 MediaType.HDDVD => HDDVD,
-                MediaType.BluRay => BD,
-                _ => Unknown,
+                MediaType.BluRay
+                    or MediaType.NintendoWiiUOpticalDisc => BD,
+
+                // Default to CD speed range
+                _ => CD,
             };
         }
     }

MPF.Frontend/MPF.Frontend.csproj

@@ -1,73 +1,45 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<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</TargetFrameworks>
+        <TargetFrameworks>net20;net35;net40;net452;net462;net472;net48;netcoreapp3.1;net5.0;net6.0;net7.0;net8.0;net9.0;net10.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.2.2</VersionPrefix>
+        <VersionPrefix>3.6.0</VersionPrefix>
 
         <!-- Package Properties -->
         <Authors>Matt Nadareski;ReignStumble;Jakz</Authors>
         <Description>Common code for all MPF frontend implementations</Description>
-        <Copyright>Copyright (c) Matt Nadareski 2019-2024</Copyright>
+        <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.Test" />
+        <InternalsVisibleTo Include="MPF.Frontend.Test" />
     </ItemGroup>
 
-    <!-- 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`))">
-        <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</TargetFrameworks>
-    </PropertyGroup>
-
     <ItemGroup>
         <ProjectReference Include="..\MPF.ExecutionContexts\MPF.ExecutionContexts.csproj" />
         <ProjectReference Include="..\MPF.Processors\MPF.Processors.csproj" />
     </ItemGroup>
 
-    <!-- Support for old .NET versions -->
-    <ItemGroup Condition="$(TargetFramework.StartsWith(`net2`)) OR $(TargetFramework.StartsWith(`net3`)) OR $(TargetFramework.StartsWith(`net40`))">
-        <PackageReference Include="MinAsyncBridge" Version="0.12.4" />
-        <PackageReference Include="MinTasksExtensionsBridge" Version="0.3.4" />
-        <PackageReference Include="MinThreadingBridge" Version="0.11.4" />
-    </ItemGroup>
-    <ItemGroup Condition="$(TargetFramework.StartsWith(`net4`)) AND !$(TargetFramework.StartsWith(`net40`))">
-        <PackageReference Include="IndexRange" Version="1.0.3" />
-    </ItemGroup>
-    <ItemGroup Condition="$(TargetFramework.StartsWith(`net452`))">
-        <PackageReference Include="Microsoft.Net.Http" Version="2.2.29" />
-    </ItemGroup>
-    <ItemGroup Condition="!$(TargetFramework.StartsWith(`net2`)) AND !$(TargetFramework.StartsWith(`net3`)) AND !$(TargetFramework.StartsWith(`net40`)) AND !$(TargetFramework.StartsWith(`net452`))">
-        <PackageReference Include="Microsoft.Management.Infrastructure" Version="3.0.0" />
-        <PackageReference Include="System.Net.Http" Version="4.3.4" />
-        <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
-    </ItemGroup>
-
     <ItemGroup>
-        <PackageReference Include="BinaryObjectScanner" PrivateAssets="build; analyzers" ExcludeAssets="contentFiles" Version="3.1.13" GeneratePathProperty="true">
-            <IncludeAssets>runtime; compile; build; native; analyzers; buildtransitive</IncludeAssets>
-        </PackageReference>
-        <PackageReference Include="LibIRD" Version="0.9.1" />
-        <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
-        <PackageReference Include="SabreTools.RedumpLib" Version="1.4.1" />
+        <PackageReference Include="BinaryObjectScanner" Version="[3.5.0]" />
+        <PackageReference Include="LibIRD" Version="[1.0.1]" />
+        <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.CommandLine" Version="[1.4.0]" />
+        <PackageReference Include="SabreTools.RedumpLib" Version="[1.9.0]" />
+        <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

@@ -1,7 +1,11 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.IO;
 using SabreTools.RedumpLib.Data;
 using AaruSettings = MPF.ExecutionContexts.Aaru.SettingConstants;
 using DICSettings = MPF.ExecutionContexts.DiscImageCreator.SettingConstants;
+using LogCompression = MPF.Processors.LogCompression;
+using RedumperDriveType = MPF.ExecutionContexts.Redumper.DriveType;
 using RedumperReadMethod = MPF.ExecutionContexts.Redumper.ReadMethod;
 using RedumperSectorOrder = MPF.ExecutionContexts.Redumper.SectorOrder;
 using RedumperSettings = MPF.ExecutionContexts.Redumper.SettingConstants;
@@ -10,6 +14,76 @@ namespace MPF.Frontend
 {
     public class Options
     {
+        #region Default Paths
+
+        /// <summary>
+        /// Default Aaru path
+        /// </summary>
+        private static string DefaultAaruPath
+        {
+            get
+            {
+                string executableName = Environment.OSVersion.Platform switch
+                {
+                    PlatformID.Unix => "aaru",
+                    PlatformID.MacOSX => "aaru",
+                    _ => "aaru.exe"
+                };
+
+#if NET20 || NET35
+                return Path.Combine("Programs", Path.Combine("Aaru", executableName));
+#else
+                return Path.Combine("Programs", "Aaru", executableName);
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Default DiscImageCreator path
+        /// </summary>
+        private static string DefaultDiscImageCreatorPath
+        {
+            get
+            {
+                string executableName = Environment.OSVersion.Platform switch
+                {
+                    PlatformID.Unix => "DiscImageCreator.out",
+                    PlatformID.MacOSX => "DiscImageCreator",
+                    _ => "DiscImageCreator.exe"
+                };
+
+#if NET20 || NET35
+                return Path.Combine("Programs", Path.Combine("Creator", executableName));
+#else
+                return Path.Combine("Programs", "Creator", executableName);
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Default Redumper path
+        /// </summary>
+        private static string DefaultRedumperPath
+        {
+            get
+            {
+                string executableName = Environment.OSVersion.Platform switch
+                {
+                    PlatformID.Unix => "redumper",
+                    PlatformID.MacOSX => "redumper",
+                    _ => "redumper.exe"
+                };
+
+#if NET20 || NET35
+                return Path.Combine("Programs", Path.Combine("Redumper", executableName));
+#else
+                return Path.Combine("Programs", "Redumper", executableName);
+#endif
+            }
+        }
+
+        #endregion
+
         /// <summary>
         /// All settings in the form of a dictionary
         /// </summary>
@@ -31,7 +105,7 @@ namespace MPF.Frontend
         /// </summary>
         public string? AaruPath
         {
-            get { return GetStringSetting(Settings, "AaruPath", "Programs\\Aaru\\Aaru.exe"); }
+            get { return GetStringSetting(Settings, "AaruPath", DefaultAaruPath); }
             set { Settings["AaruPath"] = value; }
         }
 
@@ -40,7 +114,7 @@ namespace MPF.Frontend
         /// </summary>
         public string? DiscImageCreatorPath
         {
-            get { return GetStringSetting(Settings, "DiscImageCreatorPath", "Programs\\Creator\\DiscImageCreator.exe"); }
+            get { return GetStringSetting(Settings, "DiscImageCreatorPath", DefaultDiscImageCreatorPath); }
             set { Settings["DiscImageCreatorPath"] = value; }
         }
 
@@ -49,7 +123,7 @@ namespace MPF.Frontend
         /// </summary>
         public string? RedumperPath
         {
-            get { return GetStringSetting(Settings, "RedumperPath", "Programs\\Redumper\\redumper.exe"); }
+            get { return GetStringSetting(Settings, "RedumperPath", DefaultRedumperPath); }
             set { Settings["RedumperPath"] = value; }
         }
 
@@ -61,7 +135,7 @@ namespace MPF.Frontend
             get
             {
                 var valueString = GetStringSetting(Settings, "InternalProgram", InternalProgram.Redumper.ToString());
-                var valueEnum = ToInternalProgram(valueString);
+                var valueEnum = valueString.ToInternalProgram();
                 return valueEnum == InternalProgram.NONE ? InternalProgram.Redumper : valueEnum;
             }
             set
@@ -86,6 +160,7 @@ namespace MPF.Frontend
         /// <summary>
         /// Enable purple mode for UI elements
         /// </summary>
+        /// <remarks>This is a hidden setting</remarks>
         public bool EnablePurpMode
         {
             get { return GetBooleanSetting(Settings, "EnablePurpMode", false); }
@@ -95,6 +170,7 @@ namespace MPF.Frontend
         /// <summary>
         /// Custom color setting
         /// </summary>
+        /// <remarks>This is a hidden setting</remarks>
         public string? CustomBackgroundColor
         {
             get { return GetStringSetting(Settings, "CustomBackgroundColor", null); }
@@ -104,6 +180,7 @@ namespace MPF.Frontend
         /// <summary>
         /// Custom color setting
         /// </summary>
+        /// <remarks>This is a hidden setting</remarks>
         public string? CustomTextColor
         {
             get { return GetStringSetting(Settings, "CustomTextColor", null); }
@@ -119,6 +196,15 @@ namespace MPF.Frontend
             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>
@@ -128,6 +214,22 @@ namespace MPF.Frontend
             set { Settings["FastUpdateLabel"] = value.ToString(); }
         }
 
+        /// <summary>
+        /// Default interface language to launch MPF into
+        /// </summary>
+        public InterfaceLanguage DefaultInterfaceLanguage
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "DefaultInterfaceLanguage", InterfaceLanguage.AutoDetect.ShortName());
+                return valueString.ToInterfaceLanguage();
+            }
+            set
+            {
+                Settings["DefaultInterfaceLanguage"] = value.ShortName();
+            }
+        }
+
         /// <summary>
         /// Default output path for dumps
         /// </summary>
@@ -144,18 +246,18 @@ namespace MPF.Frontend
         {
             get
             {
-                var valueString = GetStringSetting(Settings, "DefaultSystem", null);
-                var valueEnum = Extensions.ToRedumpSystem(valueString ?? string.Empty);
+                var valueString = GetStringSetting(Settings, "DefaultSystem", RedumpSystem.IBMPCcompatible.ToString());
+                var valueEnum = (valueString ?? string.Empty).ToRedumpSystem();
                 return valueEnum;
             }
             set
             {
-                Settings["DefaultSystem"] = value.LongName();
+                Settings["DefaultSystem"] = value.ToString();
             }
         }
 
         /// <summary>
-        /// Default output path for dumps
+        /// Show the debug menu item
         /// </summary>
         /// <remarks>This is a hidden setting</remarks>
         public bool ShowDebugViewMenuItem
@@ -330,21 +432,13 @@ namespace MPF.Frontend
         #region Redumper
 
         /// <summary>
-        /// Enable debug output while dumping by default
+        /// Enable skeleton output while dumping by default
         /// </summary>
-        public bool RedumperEnableDebug
+        /// <remarks>This is a hidden setting</remarks>
+        public bool RedumperEnableSkeleton
         {
-            get { return GetBooleanSetting(Settings, RedumperSettings.EnableDebug, RedumperSettings.EnableDebugDefault); }
-            set { Settings[RedumperSettings.EnableDebug] = value.ToString(); }
-        }
-
-        /// <summary>
-        /// Enable Redumper custom lead-in retries for Plextor drives
-        /// </summary>
-        public bool RedumperEnableLeadinRetry
-        {
-            get { return GetBooleanSetting(Settings, RedumperSettings.EnableLeadinRetry, RedumperSettings.EnableLeadinRetryDefault); }
-            set { Settings[RedumperSettings.EnableLeadinRetry] = value.ToString(); }
+            get { return GetBooleanSetting(Settings, RedumperSettings.EnableSkeleton, RedumperSettings.EnableSkeletonDefault); }
+            set { Settings[RedumperSettings.EnableSkeleton] = value.ToString(); }
         }
 
         /// <summary>
@@ -375,12 +469,28 @@ namespace MPF.Frontend
         }
 
         /// <summary>
-        /// Enable generic drive type by default with Redumper
+        /// Currently selected default redumper drive type
         /// </summary>
-        public bool RedumperUseGenericDriveType
+        public RedumperDriveType RedumperDriveType
         {
-            get { return GetBooleanSetting(Settings, RedumperSettings.UseGenericDriveType, RedumperSettings.UseGenericDriveTypeDefault); }
-            set { Settings[RedumperSettings.UseGenericDriveType] = value.ToString(); }
+            get
+            {
+                var valueString = GetStringSetting(Settings, RedumperSettings.DriveType, RedumperSettings.DriveTypeDefault);
+                return valueString.ToRedumperDriveType();
+            }
+            set
+            {
+                Settings[RedumperSettings.DriveType] = value.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Currently selected default redumper drive pregap start sector
+        /// </summary>
+        public int RedumperDrivePregapStart
+        {
+            get { return GetInt32Setting(Settings, RedumperSettings.DrivePregapStart, RedumperSettings.DrivePregapStartDefault); }
+            set { Settings[RedumperSettings.DrivePregapStart] = value.ToString(); }
         }
 
         /// <summary>
@@ -424,6 +534,15 @@ namespace MPF.Frontend
             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
@@ -447,7 +566,7 @@ namespace MPF.Frontend
         }
 
         /// <summary>
-        /// Show the disc information window after dumping
+        /// Show the media information window after dumping
         /// </summary>
         public bool PromptForDiscInformation
         {
@@ -469,7 +588,7 @@ namespace MPF.Frontend
         /// </summary>
         public bool EnableTabsInInputFields
         {
-            get { return GetBooleanSetting(Settings, "EnableTabsInInputFields", false); }
+            get { return GetBooleanSetting(Settings, "EnableTabsInInputFields", true); }
             set { Settings["EnableTabsInInputFields"] = value.ToString(); }
         }
 
@@ -483,7 +602,7 @@ namespace MPF.Frontend
         }
 
         /// <summary>
-        /// Show disc eject reminder before the disc information window is shown
+        /// Show disc eject reminder before the media information window is shown
         /// </summary>
         public bool ShowDiscEjectReminder
         {
@@ -536,6 +655,22 @@ namespace MPF.Frontend
             set { Settings["CompressLogFiles"] = value.ToString(); }
         }
 
+        /// <summary>
+        /// Compression type used during log compression
+        /// </summary>
+        public LogCompression LogCompression
+        {
+            get
+            {
+                var valueString = GetStringSetting(Settings, "LogCompression", LogCompression.DeflateMaximum.ToString());
+                return valueString.ToLogCompression();
+            }
+            set
+            {
+                Settings["LogCompression"] = value.ToString();
+            }
+        }
+
         /// <summary>
         /// Delete unnecessary files to reduce space
         /// </summary>
@@ -558,15 +693,6 @@ namespace MPF.Frontend
 
         #region Skip Options
 
-        /// <summary>
-        /// Skip detecting media type on disc scan
-        /// </summary>
-        public bool SkipMediaTypeDetection
-        {
-            get { return GetBooleanSetting(Settings, "SkipMediaTypeDetection", false); }
-            set { Settings["SkipMediaTypeDetection"] = value.ToString(); }
-        }
-
         /// <summary>
         /// Skip detecting known system on disc scan
         /// </summary>
@@ -589,15 +715,6 @@ namespace MPF.Frontend
             set { Settings["ScanArchivesForProtection"] = value.ToString(); }
         }
 
-        /// <summary>
-        /// Scan for executable packers during protection scanning
-        /// </summary>
-        public bool ScanPackersForProtection
-        {
-            get { return GetBooleanSetting(Settings, "ScanPackersForProtection", false); }
-            set { Settings["ScanPackersForProtection"] = value.ToString(); }
-        }
-
         /// <summary>
         /// Include debug information with scan results
         /// </summary>
@@ -642,6 +759,15 @@ namespace MPF.Frontend
 
         #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", ""); }
@@ -651,18 +777,10 @@ namespace MPF.Frontend
         // TODO: Figure out a way to keep this encrypted in some way, BASE64 to start?
         public string? RedumpPassword
         {
-            get
-            {
-                return GetStringSetting(Settings, "RedumpPassword", "");
-            }
+            get { return GetStringSetting(Settings, "RedumpPassword", ""); }
             set { Settings["RedumpPassword"] = value; }
         }
 
-        /// <summary>
-        /// Determine if a complete set of Redump credentials might exist
-        /// </summary>
-        public bool HasRedumpLogin { get => !string.IsNullOrEmpty(RedumpUsername) && !string.IsNullOrEmpty(RedumpPassword); }
-
         #endregion
 
         /// <summary>
@@ -671,7 +789,7 @@ namespace MPF.Frontend
         /// <param name="settings"></param>
         public Options(Dictionary<string, string?>? settings = null)
         {
-            this.Settings = settings ?? [];
+            Settings = settings ?? [];
         }
 
         /// <summary>
@@ -688,55 +806,12 @@ namespace MPF.Frontend
         /// </summary>
         public string? this[string key]
         {
-            get => this.Settings[key];
-            set => this.Settings[key] = value;
+            get => Settings[key];
+            set => Settings[key] = value;
         }
 
         #region Helpers
 
-        /// <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(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 a Boolean setting from a settings, dictionary
         /// </summary>
@@ -744,7 +819,7 @@ namespace MPF.Frontend
         /// <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>
-        private static bool GetBooleanSetting(Dictionary<string, string?> settings, string key, bool defaultValue)
+        internal static bool GetBooleanSetting(Dictionary<string, string?> settings, string key, bool defaultValue)
         {
             if (settings.ContainsKey(key))
             {
@@ -766,7 +841,7 @@ namespace MPF.Frontend
         /// <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>
-        private static int GetInt32Setting(Dictionary<string, string?> settings, string key, int defaultValue)
+        internal static int GetInt32Setting(Dictionary<string, string?> settings, string key, int defaultValue)
         {
             if (settings.ContainsKey(key))
             {
@@ -788,7 +863,7 @@ namespace MPF.Frontend
         /// <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>
-        private static string? GetStringSetting(Dictionary<string, string?> settings, string key, string? defaultValue)
+        internal static string? GetStringSetting(Dictionary<string, string?> settings, string key, string? defaultValue)
         {
             if (settings.ContainsKey(key))
                 return settings[key];

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/ProcessingQueue.cs

@@ -1,102 +0,0 @@
-using System;
-#if NET20 || NET35
-using System.Collections.Generic;
-#else
-using System.Collections.Concurrent;
-#endif
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MPF.Frontend
-{
-    public sealed class ProcessingQueue<T> : IDisposable
-    {
-        /// <summary>
-        /// Internal queue to hold data to process
-        /// </summary>
-#if NET20 || NET35
-        private readonly Queue<T> _internalQueue;
-#else
-        private readonly ConcurrentQueue<T> _internalQueue;
-#endif
-
-        /// <summary>
-        /// Custom processing step for dequeued data
-        /// </summary>
-        private readonly Action<T> _customProcessing;
-
-        /// <summary>
-        /// Cancellation method for the processing task
-        /// </summary>
-        private readonly CancellationTokenSource _tokenSource;
-
-        public ProcessingQueue(Action<T> customProcessing)
-        {
-#if NET20 || NET35
-            _internalQueue = new Queue<T>();
-#else
-            _internalQueue = new ConcurrentQueue<T>();
-#endif
-            _customProcessing = customProcessing;
-            _tokenSource = new CancellationTokenSource();
-#if NET20 || NET35
-            Task.Run(() => ProcessQueue());
-#elif NET40
-            Task.Factory.StartNew(() => ProcessQueue());
-#else
-            Task.Run(() => ProcessQueue(), _tokenSource.Token);
-#endif
-        }
-
-        /// <summary>
-        /// Dispose the current instance
-        /// </summary>
-        public void Dispose() => _tokenSource.Cancel();
-
-        /// <summary>
-        /// Enqueue a new item for processing
-        /// </summary>
-        /// <param name="item"></param>
-        public void Enqueue(T? item)
-        {
-            // Only accept new data when not cancelled
-            if (item != null && !_tokenSource.IsCancellationRequested)
-                _internalQueue.Enqueue(item);
-        }
-
-        /// <summary>
-        /// Process
-        /// </summary>
-        private void ProcessQueue()
-        {
-            while (true)
-            {
-                // Nothing in the queue means we get to idle
-#if NET20 || NET35
-                if (_internalQueue.Count == 0)
-#else
-                if (_internalQueue.IsEmpty)
-#endif
-                {
-                    if (_tokenSource.IsCancellationRequested)
-                        break;
-
-                    Thread.Sleep(1);
-                    continue;
-                }
-
-#if NET20 || NET35
-                // Get the next item from the queue and invoke the lambda, if possible
-                _customProcessing?.Invoke(_internalQueue.Dequeue());
-#else
-                // Get the next item from the queue
-                if (!_internalQueue.TryDequeue(out var nextItem))
-                    continue;
-
-                // Invoke the lambda, if possible
-                _customProcessing?.Invoke(nextItem);
-#endif
-            }
-        }
-    }
-}

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/StringEventArgs.cs

@@ -49,4 +49,4 @@ namespace MPF.Frontend
         /// </summary>
         public static implicit operator StringEventArgs(StringBuilder? sb) => new(sb);
     }
-}
+}

MPF.Frontend/Tools/FrontendTool.cs

@@ -1,8 +1,8 @@
 using System;
 using System.IO;
-using System.Linq;
 using System.Reflection;
 using System.Text;
+using System.Text.RegularExpressions;
 using SabreTools.RedumpLib.Data;
 
 namespace MPF.Frontend.Tools
@@ -32,6 +32,7 @@ namespace MPF.Frontend.Tools
 
                 // BD dump speed
                 MediaType.BluRay => options.PreferredDumpSpeedBD,
+                MediaType.NintendoWiiUOpticalDisc => options.PreferredDumpSpeedBD,
 
                 // Default
                 _ => options.PreferredDumpSpeedCD,
@@ -48,6 +49,9 @@ namespace MPF.Frontend.Tools
             if (string.IsNullOrEmpty(volumeLabel))
                 return null;
 
+            // Trim the volume label
+            volumeLabel = volumeLabel!.Trim();
+
             // Audio CD
             if (volumeLabel!.Equals("Audio CD", StringComparison.OrdinalIgnoreCase))
                 return RedumpSystem.AudioCD;
@@ -59,15 +63,26 @@ namespace MPF.Frontend.Tools
                 return RedumpSystem.MicrosoftXbox;
 
             // Microsoft Xbox 360
-            if (volumeLabel.Equals("XBOX360", StringComparison.OrdinalIgnoreCase))
+            if (volumeLabel.Equals("XBOX360"))
                 return RedumpSystem.MicrosoftXbox360;
-            else if (volumeLabel.Equals("XGD2DVD_NTSC", StringComparison.OrdinalIgnoreCase))
+            else if (volumeLabel.Equals("XGD2DVD_NTSC"))
                 return RedumpSystem.MicrosoftXbox360;
-
-            // Microsoft Xbox 360 - Too overly broad even if a lot of discs use this
-            //if (volumeLabel.Equals("CD_ROM", StringComparison.OrdinalIgnoreCase))
-            //    return RedumpSystem.MicrosoftXbox360; // Also for Xbox One?
-            //if (volumeLabel.Equals("DVD_ROM", StringComparison.OrdinalIgnoreCase))
+            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
@@ -115,7 +130,7 @@ namespace MPF.Frontend.Tools
             }
 
             // If we didn't already try English, try it now
-            if (!languages.Contains(Language.English))
+            if (!Array.Exists(languages, l => l == Language.English))
                 return NormalizeDiscTitle(title, Language.English);
 
             // If all fails, then the title didn't need normalization
@@ -139,11 +154,10 @@ namespace MPF.Frontend.Tools
                 return title;
 
             // If we have an invalid language, assume Language.English
-            if (language == null)
-                language = Language.English;
+            language ??= Language.English;
 
             // Get the title split into parts
-            string[] splitTitle = title!.Split(' ').Where(s => !string.IsNullOrEmpty(s)).ToArray();
+            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)
@@ -484,12 +498,20 @@ namespace MPF.Frontend.Tools
                 else if (!itemInserted && segment.EndsWith(":"))
                 {
                     itemInserted = true;
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+                    newTitleBuilder.Append($" {segment[..^1]}, {firstItem}:");
+#else
                     newTitleBuilder.Append($" {segment.Substring(0, segment.Length - 1)}, {firstItem}:");
+#endif
                 }
                 else if (!itemInserted && segment.EndsWith("-"))
                 {
                     itemInserted = true;
+#if NETCOREAPP || NETSTANDARD2_1_OR_GREATER
+                    newTitleBuilder.Append($" {segment[..^1]}, {firstItem}-");
+#else
                     newTitleBuilder.Append($" {segment.Substring(0, segment.Length - 1)}, {firstItem}-");
+#endif
                 }
                 else
                 {
@@ -511,7 +533,6 @@ namespace MPF.Frontend.Tools
         /// <param name="path">Path value to normalize</param>
         public static string NormalizeOutputPaths(string? path, bool getFullPath)
         {
-            // The easy way
             try
             {
                 // If we have an invalid path
@@ -519,30 +540,33 @@ namespace MPF.Frontend.Tools
                     return string.Empty;
 
                 // Remove quotes and angle brackets from path
-                path = path!.Replace("\"", string.Empty);
-                path = path!.Replace("<", string.Empty);
-                path = path!.Replace(">", string.Empty);
+                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);
-                string fullFile = Path.GetFileName(fullPath);
-
-                // Remove invalid path characters
-                if (fullDirectory != null)
-                {
-                    foreach (char c in Path.GetInvalidPathChars())
-                        fullDirectory = fullDirectory.Replace(c, '_');
-                }
+                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, '_');
+                }
 
-                if (string.IsNullOrEmpty(fullDirectory))
-                    return fullFile;
-                else
-                    return Path.Combine(fullDirectory, fullFile);
+                // 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 { }
 
@@ -561,32 +585,37 @@ namespace MPF.Frontend.Tools
         /// String representing the message to display the the user.
         /// String representing the new release URL.
         /// </returns>
-        public static (bool different, string message, string? url) CheckForNewVersion()
+        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)
-                    return (false, "Assembly version could not be determined", 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
-                var (tag, url) = GetRemoteVersionAndUrl();
-                bool different = version != tag && tag != null;
+                _ = GetRemoteVersionAndUrl(out string? tag, out url);
+                different = version != tag && tag != null;
 
-                string message = $"Local version: {version}"
+                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!");
-
-                return (different, message, url);
             }
             catch (Exception ex)
             {
-                return (false, ex.ToString(), null);
+                different = false;
+                message = ex.ToString();
+                url = null;
             }
         }
 
@@ -613,11 +642,12 @@ namespace MPF.Frontend.Tools
         /// <summary>
         /// Get the latest version of MPF from GitHub and the release URL
         /// </summary>
-        private static (string? tag, string? url) GetRemoteVersionAndUrl()
+        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 (null, null);
+            return false;
 #else
             using var hc = new System.Net.Http.HttpClient();
 #if NET452
@@ -625,25 +655,25 @@ namespace MPF.Frontend.Tools
 #endif
 
             // TODO: Figure out a better way than having this hardcoded...
-            string url = "https://api.github.com/repos/SabreTools/MPF/releases/latest";
-            var message = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Get, url);
+            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 (null, null);
+                return false;
 
             var latestReleaseJson = Newtonsoft.Json.Linq.JObject.Parse(latestReleaseJsonString);
             if (latestReleaseJson == null)
-                return (null, null);
+                return false;
 
-            var latestTag = latestReleaseJson["tag_name"]?.ToString();
-            var releaseUrl = latestReleaseJson["html_url"]?.ToString();
+            tag = latestReleaseJson["tag_name"]?.ToString();
+            url = latestReleaseJson["html_url"]?.ToString();
 
-            return (latestTag, releaseUrl);
+            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)
+            {
+                // Absorb the exception
+                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)
+            {
+                // Absorb the exception
+                return false;
+            }
+        }
+    }
+}

MPF.Frontend/Tools/OptionsLoader.cs

@@ -9,121 +9,37 @@ 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>
-#if NET20 || NET35 || NET40 || NET452
-        private static string ConfigurationPath => Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "config.json");
-#else
-        private static string ConfigurationPath => Path.Combine(AppContext.BaseDirectory, "config.json");
-#endif
+        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] == "-?")
-                return false;
-
-            // List options
-            if (args[0] == "-lc" || args[0] == "--listcodes")
-            {
-                Console.WriteLine("Supported Site Codes:");
-                foreach (string siteCode in Extensions.ListSiteCodes())
-                {
-                    Console.WriteLine(siteCode);
-                }
-                Console.ReadLine();
-                return true;
-            }
-            else if (args[0] == "-lm" || args[0] == "--listmedia")
-            {
-                Console.WriteLine("Supported Media Types:");
-                foreach (string mediaType in Extensions.ListMediaTypes())
-                {
-                    Console.WriteLine(mediaType);
-                }
-                Console.ReadLine();
-                return true;
-            }
-            else if (args[0] == "-lp" || args[0] == "--listprograms")
-            {
-                Console.WriteLine("Supported Programs:");
-                foreach (string program in ListPrograms())
-                {
-                    Console.WriteLine(program);
-                }
-                Console.ReadLine();
-                return true;
-            }
-            else if (args[0] == "-ls" || args[0] == "--listsystems")
-            {
-                Console.WriteLine("Supported Systems:");
-                foreach (string system in Extensions.ListSystems())
-                {
-                    Console.WriteLine(system);
-                }
-                Console.ReadLine();
-                return true;
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Process common arguments for all functionality
-        /// </summary>
-        /// <returns>True if all arguments pass, false otherwise</returns>
-        public static (bool, MediaType, RedumpSystem?, string?) ProcessCommonArguments(string[] args)
-        {
-            // All other use requires at least 3 arguments
-            if (args.Length < 3)
-                return (false, MediaType.NONE, null, "Invalid number of arguments");
-
-            // Check the MediaType
-            var mediaType = ToMediaType(args[0].Trim('"'));
-            if (mediaType == MediaType.NONE)
-                return (false, MediaType.NONE, null, $"{args[0]} is not a recognized media type");
-
-            // Check the RedumpSystem
-            var knownSystem = Extensions.ToRedumpSystem(args[1].Trim('"'));
-            if (knownSystem == null)
-                return (false, MediaType.NONE, null, $"{args[1]} is not a recognized system");
-
-            return (true, mediaType, knownSystem, null);
-        }
-
-        /// <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).LongName()}");
-            }
-
-            return programs;
-        }
-
         /// <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>
-        private static MediaType ToMediaType(string type)
+        public static MediaType ToMediaType(string? type)
         {
-            return (type.ToLowerInvariant()) switch
+            return (type?.ToLowerInvariant()) switch
             {
                 #region Punched Media
 
@@ -268,54 +184,102 @@ namespace MPF.Frontend.Tools
         /// </summary>
         public static Options LoadFromConfig()
         {
-            if (!File.Exists(ConfigurationPath))
-            {
-                File.Create(ConfigurationPath).Dispose();
+            // If no options path can be found
+            if (string.IsNullOrEmpty(ConfigurationPath))
+                return new Options();
+
+            // If the file does not exist
+            if (!File.Exists(ConfigurationPath) || new FileInfo(ConfigurationPath).Length == 0)
                 return new Options();
-            }
 
             var serializer = JsonSerializer.Create();
-            var stream = File.Open(ConfigurationPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
-            var reader = new StreamReader(stream);
+            var stream = File.Open(ConfigurationPath, FileMode.Open, FileAccess.Read, FileShare.None);
+            using 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, bool saveDefault = false)
+        public static void SaveToConfig(Options options)
         {
-            // If default values should be saved as well
-            if (saveDefault)
+            // 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)
             {
-                PropertyInfo[] properties = typeof(Options).GetProperties();
-                foreach (var property in properties)
-                {
-                    // Skip dictionary properties
-                    if (property.Name == "Item")
-                        continue;
+                // Skip dictionary properties
+                if (property.Name == "Item")
+                    continue;
 
-                    // Skip non-option properties
-                    if (property.Name == "Settings" || property.Name == "HasRedumpLogin")
-                        continue;
+                // Skip non-option properties
+                if (property.Name == "Settings" || property.Name == "HasRedumpLogin")
+                    continue;
 
-                    var val = property.GetValue(options, null);
-                    property.SetValue(options, val, null);
-                }
+                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 stream = File.Open(ConfigurationPath, FileMode.Create, FileAccess.Write, FileShare.None);
+            using var sw = new StreamWriter(stream) { 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
     }
 }