From db113299a116b26d61a963f9d30b861edd4d2fd9 Mon Sep 17 00:00:00 2001
From: "Muhammad A." <16158433+kopihitam@users.noreply.github.com>
Date: Sat, 31 Oct 2026 12:27:25 +0800
Subject: [PATCH] Let the user choose where temporary work files go

Converting an image, converting a package to an image, and editing the
details of an FFPFSC image or a package unpack the whole game first. That
always went to the system temporary folder, which could fill the C: drive.

- Settings > Temporary folder picks another folder; blank keeps the system
  temporary folder. "Keep temporary files next to the output instead" puts
  them in a .Packwright-* folder beside the output, on the same drive.
- The command line follows the setting, and --temp <folder> overrides it.
- A folder that cannot be created fails the job with a message naming it,
  instead of falling back to the system drive. Only each job's own
  subfolder is deleted, never the chosen folder.
- The library scan skips .Packwright-* work folders, so a half-unpacked
  game next to an output is not listed as a title.
- New smoke test: SmokeTests temp-folders <work folder>.

Closes itsmemac/Packwright#2

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 README.md                                     |   2 +-
 src/Packwright.App/Cli.cs                     |  11 +-
 .../Infrastructure/AppSettingsNormalizer.cs   |   1 +
 .../Infrastructure/AppStateStore.cs           |   4 +
 src/Packwright.App/Services/AppServices.cs    |   3 +
 src/Packwright.App/Services/MetadataEditor.cs |   3 +-
 src/Packwright.App/Views/SettingsView.axaml   |   8 ++
 .../Views/SettingsView.axaml.cs               |  25 ++++
 .../ImageConversionService.cs                 |   9 +-
 src/Packwright.Containers/TemporaryFolders.cs |  57 +++++++++
 .../Services/Ps5DumpLocator.cs                |  11 ++
 .../Services/Ps5PackageImageConversion.cs     |   3 +-
 tests/Packwright.SmokeTests/Program.cs        |   1 +
 .../Packwright.SmokeTests/TempFolderTests.cs  | 120 ++++++++++++++++++
 14 files changed, 248 insertions(+), 10 deletions(-)
 create mode 100644 src/Packwright.Containers/TemporaryFolders.cs
 create mode 100644 tests/Packwright.SmokeTests/TempFolderTests.cs

diff --git a/README.md b/README.md
index 434ef1d..16e7a3d 100644
--- a/README.md
+++ b/README.md
@@ -240,7 +240,7 @@ Example: `id:PPSA01 size:>20GB -dlc | category:patch`.
 | Settings (including consoles and presets), library cache, task history | Windows `%LOCALAPPDATA%\Packwright`, Linux and macOS `~/.local/share/Packwright` |
 | Library-only edits (`metadata-overrides.json`, `overrides/` for custom icons) | the same folder |
 | Logs | `logs/` inside that folder (also shown on the **Log** page) |
-| Temporary work files | your system temporary folder (only used when an image has to be unpacked first) |
+| Temporary work files | your system temporary folder, or the one chosen under **Settings > Temporary folder** (or next to the output); only used when an image has to be unpacked first. The command line takes `--temp <folder>` too |
 
 Delete the folder to reset the app. Setting the `PACKWRIGHT_DATA` environment variable to a folder makes a separate copy of the app use that folder instead (handy for testing).
 
diff --git a/src/Packwright.App/Cli.cs b/src/Packwright.App/Cli.cs
index 51023c9..cc3e522 100644
--- a/src/Packwright.App/Cli.cs
+++ b/src/Packwright.App/Cli.cs
@@ -29,7 +29,8 @@ internal static class Cli
     private static readonly HashSet<string> ValueOptions = new(StringComparer.OrdinalIgnoreCase)
     {
         "to", "o", "output", "preset", "passcode", "level", "gain", "cluster", "block", "fragment", "density", "min-free",
-        "compression", "kraken-level", "threads", "playgo", "drm", "format", "folder", "host", "port", "user", "password"
+        "compression", "kraken-level", "threads", "playgo", "drm", "format", "folder", "host", "port", "user", "password",
+        "temp"
     };
 
     public static bool IsCommand(string[] args) =>
@@ -165,6 +166,7 @@ version                      Print the version.
 
             convert options:
               -o, --output <file>   Where to write it (default: next to the source).  --overwrite replaces an existing file.
+              --temp <folder>       Where to unpack work files (default: the folder chosen in Settings, or the system temp).
               --preset <name>       Use a saved or built-in preset from the Tools page (its target and options).
               --level 1-9  --gain 0-100            FFPFSC compression
               --cluster 32|64  --no-ampr           exFAT
@@ -357,6 +359,13 @@ private static async Task<int> JobAsync(string command, Options options, Cancell
 
         Func<IProgress<PackageTaskProgress>, CancellationToken, Task>? run = spec.Executor();
         if (run is null) return Fail("That job cannot run with these arguments.", Usage);
+        // Work files go where Settings says, unless --temp names a folder for this run.
+        if (options.Get("temp") is { } temp) TemporaryFolders.Configure(temp, nextToOutput: false);
+        else
+        {
+            AppSettings saved = new AppStateStore().LoadSettings();
+            TemporaryFolders.Configure(saved.TempDirectory, saved.TempNextToOutput);
+        }
         var printer = new ConsoleProgress();
         Console.Error.WriteLine($"{command}: {source}");
         if (spec.Output.Length > 0) Console.Error.WriteLine("   -> " + spec.Output);
diff --git a/src/Packwright.App/Infrastructure/AppSettingsNormalizer.cs b/src/Packwright.App/Infrastructure/AppSettingsNormalizer.cs
index 4d2149e..f2bcc33 100644
--- a/src/Packwright.App/Infrastructure/AppSettingsNormalizer.cs
+++ b/src/Packwright.App/Infrastructure/AppSettingsNormalizer.cs
@@ -52,6 +52,7 @@ public static AppSettings Normalize(AppSettings? settings)
         settings.ThumbnailCacheCount = Math.Clamp(settings.ThumbnailCacheCount, MinThumbnailCache, MaxThumbnailCache);
 
         settings.OutputDirectory = (settings.OutputDirectory ?? string.Empty).Trim();
+        settings.TempDirectory = (settings.TempDirectory ?? string.Empty).Trim();
 
         // A passcode is either blank (meaning the built-in all-zero default) or exactly 32 printable
         // ASCII characters. Anything else is discarded rather than carried into a build.
diff --git a/src/Packwright.App/Infrastructure/AppStateStore.cs b/src/Packwright.App/Infrastructure/AppStateStore.cs
index 05ad840..b9f7542 100644
--- a/src/Packwright.App/Infrastructure/AppStateStore.cs
+++ b/src/Packwright.App/Infrastructure/AppStateStore.cs
@@ -118,6 +118,10 @@ public sealed class AppSettings
     // Paths & outputs
     public string OutputDirectory { get; set; } = string.Empty;
     public bool OpenOutputAfterTask { get; set; }
+    /// <summary>Where conversions and edits unpack their work files; empty is the system temporary folder.</summary>
+    public string TempDirectory { get; set; } = string.Empty;
+    /// <summary>Keep work files next to the output instead, on the same drive.</summary>
+    public bool TempNextToOutput { get; set; }
 
     // Tasks workspace
     /// <summary>Remembered vertical split between the task list and the details panel.</summary>
diff --git a/src/Packwright.App/Services/AppServices.cs b/src/Packwright.App/Services/AppServices.cs
index 375d6b8..de2927b 100644
--- a/src/Packwright.App/Services/AppServices.cs
+++ b/src/Packwright.App/Services/AppServices.cs
@@ -1,3 +1,4 @@
+using Packwright.Containers;
 using Packwright.Core.Models;
 using Packwright.Core.Services;
 using Packwright.Core.Tasks;
@@ -19,6 +20,7 @@ private AppServices()
         SettingsLoadResult loaded = Store.LoadSettingsWithDiagnostics();
         Settings = loaded.Settings;
         SettingsWarning = loaded.Warning;
+        TemporaryFolders.Configure(Settings.TempDirectory, Settings.TempNextToOutput);
         Queue = new PackageTaskQueue();
         Queue.TasksChanged += (_, _) => LogTaskChanges();
         string taskFile = Path.Combine(Store.AppDataDirectory, "studio-tasks.json");
@@ -160,6 +162,7 @@ public void SaveSettings()
     public void ReplaceSettings(AppSettings settings)
     {
         Settings = AppSettingsNormalizer.Normalize(settings);
+        TemporaryFolders.Configure(Settings.TempDirectory, Settings.TempNextToOutput);
         SaveSettings();
     }
 
diff --git a/src/Packwright.App/Services/MetadataEditor.cs b/src/Packwright.App/Services/MetadataEditor.cs
index 9bd22fa..a75aedd 100644
--- a/src/Packwright.App/Services/MetadataEditor.cs
+++ b/src/Packwright.App/Services/MetadataEditor.cs
@@ -236,8 +236,7 @@ public static async Task ApplyAsync(string source, string output, bool fromPacka
         if (!inPlace && (File.Exists(target) || Directory.Exists(target)))
             throw new IOException("The output already exists: " + target);
 
-        string work = Path.Combine(Path.GetTempPath(), "Packwright-edit-" + Guid.NewGuid().ToString("N"));
-        Directory.CreateDirectory(work);
+        string work = TemporaryFolders.Create("edit", target);
         try
         {
             byte[]? icon = edit.IconPath.Length > 0 ? await File.ReadAllBytesAsync(edit.IconPath, token).ConfigureAwait(false) : null;
diff --git a/src/Packwright.App/Views/SettingsView.axaml b/src/Packwright.App/Views/SettingsView.axaml
index 497199f..a54e9ab 100644
--- a/src/Packwright.App/Views/SettingsView.axaml
+++ b/src/Packwright.App/Views/SettingsView.axaml
@@ -45,6 +45,14 @@
               <Button x:Name="BrowseOutputButton" DockPanel.Dock="Right" Content="Browse..." Margin="8,0,0,0" />
               <TextBox x:Name="OutputBox" Watermark="Next to the source when empty" />
             </DockPanel>
+            <TextBlock Text="Temporary folder" Classes="h" Margin="0,6,0,0" />
+            <DockPanel>
+              <Button x:Name="BrowseTempButton" DockPanel.Dock="Right" Content="Browse..." Margin="8,0,0,0" />
+              <TextBox x:Name="TempBox" Watermark="System temporary folder when empty" />
+            </DockPanel>
+            <CheckBox x:Name="TempNextToOutputBox" Content="Keep temporary files next to the output instead" />
+            <TextBlock Classes="muted" FontSize="11" TextWrapping="Wrap"
+                       Text="Converting an image, or editing the details of an FFPFSC image or a package, unpacks the whole game here first, so it needs about as much free space as the game." />
             <TextBlock Text="Custom rename format" Classes="h" Margin="0,6,0,6" />
             <TextBox x:Name="RenameFormatBox" Watermark="{}{TITLE} [{TITLE_ID}]" />
             <TextBlock x:Name="RenameTokens" Classes="muted" FontSize="11" TextWrapping="Wrap" />
diff --git a/src/Packwright.App/Views/SettingsView.axaml.cs b/src/Packwright.App/Views/SettingsView.axaml.cs
index 2d853ef..069bfd8 100644
--- a/src/Packwright.App/Views/SettingsView.axaml.cs
+++ b/src/Packwright.App/Views/SettingsView.axaml.cs
@@ -43,6 +43,11 @@ public SettingsView()
         {
             if (await Dialogs.PickFolderAsync(this, "Default output folder") is { } folder) OutputBox.Text = folder;
         };
+        BrowseTempButton.Click += async (_, _) =>
+        {
+            if (await Dialogs.PickFolderAsync(this, "Temporary folder") is { } folder) TempBox.Text = folder;
+        };
+        TempNextToOutputBox.IsCheckedChanged += (_, _) => UpdateTempControls();
         SaveButton.Click += async (_, _) => await SaveAsync();
         ConsolesButton.Click += async (_, _) => await ConsolesWindow.ShowAsync(Dialogs.OwnerOf(this));
         WindowsCard.IsVisible = OperatingSystem.IsWindows();
@@ -105,6 +110,9 @@ private void Load()
         ViewBox.SelectedItem = Layouts.Contains(settings.LibraryLayout) ? settings.LibraryLayout : "Cards";
         ThumbnailsBox.IsChecked = settings.ShowThumbnails;
         OutputBox.Text = settings.OutputDirectory;
+        TempBox.Text = settings.TempDirectory;
+        TempNextToOutputBox.IsChecked = settings.TempNextToOutput;
+        UpdateTempControls();
         RenameFormatBox.Text = settings.RenameFormat;
         OpenOutputBox.IsChecked = settings.OpenOutputAfterTask;
         PreviewMbBox.Value = settings.MaxPreviewMb;
@@ -116,6 +124,14 @@ private void Load()
         ShowKeysStatus();
     }
 
+    /// <summary>The folder box only matters when temporary files are not kept next to the output.</summary>
+    private void UpdateTempControls()
+    {
+        bool beside = TempNextToOutputBox.IsChecked == true;
+        TempBox.IsEnabled = !beside;
+        BrowseTempButton.IsEnabled = !beside;
+    }
+
     private void ShowKeysStatus()
     {
         Jobs.EnsureKeys();
@@ -161,6 +177,13 @@ await Dialogs.ShowMessageAsync(Dialogs.OwnerOf(this), "Settings",
                 "The passcode must be exactly 32 characters, or blank for the default.");
             return;
         }
+        string tempFolder = TempBox.Text?.Trim() ?? string.Empty;
+        if (tempFolder.Length > 0 && !System.IO.Path.IsPathFullyQualified(tempFolder))
+        {
+            await Dialogs.ShowMessageAsync(Dialogs.OwnerOf(this), "Settings",
+                "The temporary folder must be a full path, such as D:\\Temp, or blank for the system temporary folder.");
+            return;
+        }
         AppSettings settings = _services.Settings;
         // Files and items that were added individually stay manual sources; the rest are library folders.
         settings.ManualSources = _folders.Where(path => File.Exists(path) || _manual.Contains(path)).ToList();
@@ -172,6 +195,8 @@ await Dialogs.ShowMessageAsync(Dialogs.OwnerOf(this), "Settings",
         settings.LibraryLayout = ViewBox.SelectedItem as string ?? "Cards";
         settings.ShowThumbnails = ThumbnailsBox.IsChecked == true;
         settings.OutputDirectory = OutputBox.Text?.Trim() ?? string.Empty;
+        settings.TempDirectory = tempFolder;
+        settings.TempNextToOutput = TempNextToOutputBox.IsChecked == true;
         settings.RenameFormat = RenameFormatBox.Text?.Trim() ?? string.Empty;
         settings.OpenOutputAfterTask = OpenOutputBox.IsChecked == true;
         settings.MaxPreviewMb = (int)(PreviewMbBox.Value ?? 16);
diff --git a/src/Packwright.Containers/ImageConversionService.cs b/src/Packwright.Containers/ImageConversionService.cs
index 179e8a7..8d2fe58 100644
--- a/src/Packwright.Containers/ImageConversionService.cs
+++ b/src/Packwright.Containers/ImageConversionService.cs
@@ -122,7 +122,7 @@ public static async Task<Ps5ImageConversionResult> ConvertAsync(string sourcePat
             throw new InvalidDataException(
                 $"Converting {sourceFormat} to {target} is not supported.");
 
-        string tempRoot = Path.Combine(Path.GetTempPath(), "Packwright", "convert", Guid.NewGuid().ToString("N"));
+        string? tempRoot = null;
         string? tempOutput = null;
         try
         {
@@ -135,13 +135,14 @@ public static async Task<Ps5ImageConversionResult> ConvertAsync(string sourcePat
             }
             else
             {
-                Directory.CreateDirectory(tempRoot);
+                tempRoot = TemporaryFolders.Create("convert", outputFull);
                 tree = Path.Combine(tempRoot, "tree");
                 await ExtractAsync(sourceFull, tree, sourceFormat, progress, cancellationToken).ConfigureAwait(false);
                 fileCount = Directory.EnumerateFiles(tree, "*", SearchOption.AllDirectories).Count();
             }
 
-            string outputDirectory = Path.GetDirectoryName(outputFull) ?? tempRoot;
+            string outputDirectory = Path.GetDirectoryName(outputFull)
+                ?? throw new IOException("The output path has no parent folder: " + outputFull);
             Directory.CreateDirectory(outputDirectory);
             tempOutput = outputFull + "." + Guid.NewGuid().ToString("N") + ".tmp";
             await BuildAsync(tree, tempOutput, target, BuildVolumeName(sourceFull), progress, cancellationToken, exfatOptions, ffpfscOptions, ffpkgOptions)
@@ -164,7 +165,7 @@ await BuildAsync(tree, tempOutput, target, BuildVolumeName(sourceFull), progress
         finally
         {
             if (tempOutput is not null) TryDelete(tempOutput);
-            if (Directory.Exists(tempRoot)) TryDeleteDirectory(tempRoot);
+            if (tempRoot is not null && Directory.Exists(tempRoot)) TryDeleteDirectory(tempRoot);
         }
     }
 
diff --git a/src/Packwright.Containers/TemporaryFolders.cs b/src/Packwright.Containers/TemporaryFolders.cs
new file mode 100644
index 0000000..6414fbf
--- /dev/null
+++ b/src/Packwright.Containers/TemporaryFolders.cs
@@ -0,0 +1,57 @@
+namespace Packwright.Containers;
+
+/// <summary>
+/// Where large temporary work files go (an image unpacked to a folder, a copy of an image being edited). By default
+/// that is the system temporary folder; another folder can be chosen, or the files can be kept next to the output, so
+/// a big conversion does not fill the system drive.
+/// </summary>
+public static class TemporaryFolders
+{
+    private sealed record Choice(string Root, bool NextToOutput);
+
+    private static volatile Choice _choice = new(string.Empty, false);
+
+    /// <summary>The chosen folder, or empty for the system temporary folder.</summary>
+    public static string Root => _choice.Root;
+
+    /// <summary>True when work files are kept next to the output instead.</summary>
+    public static bool NextToOutput => _choice.NextToOutput;
+
+    /// <summary>Sets where later jobs write their work files. A job that is already running keeps its folder.</summary>
+    public static void Configure(string? root, bool nextToOutput)
+    {
+        string folder = string.IsNullOrWhiteSpace(root) ? string.Empty : root.Trim();
+        if (folder.Length > 0)
+        {
+            try { folder = Path.GetFullPath(folder); }
+            catch (Exception ex) when (ex is ArgumentException or NotSupportedException or PathTooLongException) { }
+        }
+        _choice = new Choice(folder, nextToOutput);
+    }
+
+    /// <summary>
+    /// Creates a new, empty folder for one job and returns it. The caller deletes that folder when done; the chosen
+    /// folder itself is never removed. <paramref name="outputPath"/> is the file or folder the job writes, used when
+    /// work files are kept next to the output.
+    /// </summary>
+    public static string Create(string purpose, string outputPath)
+    {
+        Choice choice = _choice;
+        string id = Guid.NewGuid().ToString("N");
+        string? beside = choice.NextToOutput ? Path.GetDirectoryName(Path.GetFullPath(outputPath)) : null;
+        string folder = !string.IsNullOrEmpty(beside)
+            ? Path.Combine(beside, $".Packwright-{purpose}-{id}")
+            : Path.Combine(choice.Root.Length > 0 ? choice.Root : Path.GetTempPath(), "Packwright", purpose, id);
+        try
+        {
+            Directory.CreateDirectory(folder);
+        }
+        catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException or NotSupportedException)
+        {
+            // Never fall back to the system drive on its own: running out of room there is what the setting avoids.
+            throw new IOException($"The temporary folder could not be created: {folder}. {ex.Message.Trim()} " +
+                                  "Choose another temporary folder.", ex);
+        }
+        return folder;
+    }
+}
diff --git a/src/Packwright.Core/Services/Ps5DumpLocator.cs b/src/Packwright.Core/Services/Ps5DumpLocator.cs
index 2a5b904..aa67006 100644
--- a/src/Packwright.Core/Services/Ps5DumpLocator.cs
+++ b/src/Packwright.Core/Services/Ps5DumpLocator.cs
@@ -64,8 +64,19 @@ public LocatedSources FindAll(string selectedPath, bool recursive, CancellationT
         return found;
     }
 
+    /// <summary>
+    /// True for a file inside a job's work folder (<c>.Packwright-convert-…</c>, <c>.Packwright-exfat-edit-…</c> and
+    /// so on), which can sit next to an output in a library folder while a job runs. Its half-built dump or image copy
+    /// is not a title.
+    /// </summary>
+    public static bool IsInWorkFolder(string fullPath) =>
+        fullPath.Contains(Path.DirectorySeparatorChar + ".Packwright-", StringComparison.OrdinalIgnoreCase) ||
+        (Path.AltDirectorySeparatorChar != Path.DirectorySeparatorChar &&
+         fullPath.Contains(Path.AltDirectorySeparatorChar + ".Packwright-", StringComparison.OrdinalIgnoreCase));
+
     private static void Classify(string fullPath, LocatedSources found)
     {
+        if (IsInWorkFolder(fullPath)) return;
         string name = Path.GetFileName(fullPath);
         if (name.Equals("param.json", StringComparison.OrdinalIgnoreCase))
         {
diff --git a/src/Packwright.Core/Services/Ps5PackageImageConversion.cs b/src/Packwright.Core/Services/Ps5PackageImageConversion.cs
index 0db2db3..0b3f020 100644
--- a/src/Packwright.Core/Services/Ps5PackageImageConversion.cs
+++ b/src/Packwright.Core/Services/Ps5PackageImageConversion.cs
@@ -29,8 +29,7 @@ public static async Task<Ps5ImageConversionResult> ConvertAsync(string packagePa
         if (string.Equals(packageFull, outputFull, StringComparison.OrdinalIgnoreCase))
             throw new IOException("The output path must be different from the source package.");
 
-        string tempRoot = Path.Combine(Path.GetTempPath(), "Packwright", "pkg-image",
-            Guid.NewGuid().ToString("N"));
+        string tempRoot = TemporaryFolders.Create("pkg-image", outputFull);
         string tree = Path.Combine(tempRoot, "tree");
         try
         {
diff --git a/tests/Packwright.SmokeTests/Program.cs b/tests/Packwright.SmokeTests/Program.cs
index 3c40398..ca1dd49 100644
--- a/tests/Packwright.SmokeTests/Program.cs
+++ b/tests/Packwright.SmokeTests/Program.cs
@@ -114,6 +114,7 @@
     return 0;
 }
 if (args.Length == 5 && args[0] == "edit-tests") return await Packwright.SmokeTests.EditTests.Run(args);
+if (args.Length == 2 && args[0] == "temp-folders") return await Packwright.SmokeTests.TempFolderTests.Run(args);
 if (args.Length == 2 && args[0] == "ampr-refresh")
 {
     var result = await Packwright.Containers.ExfatAmprPatcher.RefreshAsync(args[1]);
diff --git a/tests/Packwright.SmokeTests/TempFolderTests.cs b/tests/Packwright.SmokeTests/TempFolderTests.cs
new file mode 100644
index 0000000..48f5530
--- /dev/null
+++ b/tests/Packwright.SmokeTests/TempFolderTests.cs
@@ -0,0 +1,120 @@
+using Packwright.App.Services;
+using Packwright.Containers;
+using Packwright.Core.Services;
+using Packwright.Core.Tasks;
+
+namespace Packwright.SmokeTests;
+
+/// <summary>
+/// Where conversions and edits put their work files: the system temporary folder, a chosen folder, or next to the
+/// output. Builds a small dump of its own, so no game is needed.
+/// Usage: SmokeTests temp-folders &lt;work folder&gt;
+/// </summary>
+internal static class TempFolderTests
+{
+    private static int _failures;
+
+    public static async Task<int> Run(string[] args)
+    {
+        string work = Path.GetFullPath(args[1]);
+        if (Directory.Exists(work)) Directory.Delete(work, true);
+        Directory.CreateDirectory(work);
+        try
+        {
+            string dump = MakeDump(Path.Combine(work, "dump"));
+            string outputs = Path.Combine(work, "out");
+            string exfat = Path.Combine(outputs, "game.exfat");
+            TemporaryFolders.Configure(null, nextToOutput: false);
+            await Ps5ImageConversionService.ConvertAsync(dump, exfat, Ps5ImageConversionTarget.Exfat);
+
+            Console.WriteLine("== where a job folder is made");
+            string chosen = Path.Combine(work, "chosen temp");
+            string system = TemporaryFolders.Create("selftest", exfat);
+            Check("empty uses the system temporary folder", system.StartsWith(Path.GetTempPath(), StringComparison.OrdinalIgnoreCase));
+            Directory.Delete(system);
+            TemporaryFolders.Configure(chosen, nextToOutput: false);
+            string inChosen = TemporaryFolders.Create("selftest", exfat);
+            Check("a chosen folder is used", inChosen.StartsWith(chosen + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase));
+            Directory.Delete(inChosen);
+            TemporaryFolders.Configure(chosen, nextToOutput: true);
+            string beside = TemporaryFolders.Create("selftest", exfat);
+            Check("next to the output wins over the chosen folder",
+                string.Equals(Path.GetDirectoryName(beside), outputs, StringComparison.OrdinalIgnoreCase) &&
+                Path.GetFileName(beside).StartsWith(".Packwright-selftest-", StringComparison.Ordinal));
+            Directory.Delete(beside);
+
+            Console.WriteLine("\n== converting exFAT to ZArchive (unpacks the image first)");
+            TemporaryFolders.Configure(chosen, nextToOutput: false);
+            string zar = Path.Combine(outputs, "game.zar");
+            await Ps5ImageConversionService.ConvertAsync(exfat, zar, Ps5ImageConversionTarget.ZArchive);
+            Check("converts with a chosen folder", File.Exists(zar));
+            Check("the chosen folder is kept", Directory.Exists(chosen));
+            Check("the job's folder is removed", NoJobFolders(Path.Combine(chosen, "Packwright", "convert")));
+
+            TemporaryFolders.Configure(chosen, nextToOutput: true);
+            string zarBeside = Path.Combine(outputs, "game-beside.zar");
+            await Ps5ImageConversionService.ConvertAsync(exfat, zarBeside, Ps5ImageConversionTarget.ZArchive);
+            Check("converts with work files next to the output", File.Exists(zarBeside));
+            Check("nothing is left next to the output",
+                !Directory.EnumerateDirectories(outputs, ".Packwright-*").Any());
+
+            Console.WriteLine("\n== a temporary folder that cannot be made");
+            string blocker = Path.Combine(work, "a file");
+            File.WriteAllText(blocker, "not a folder");
+            TemporaryFolders.Configure(Path.Combine(blocker, "temp"), nextToOutput: false);
+            string blocked = Path.Combine(outputs, "blocked.zar");
+            string? message = await FailureOf(() => Ps5ImageConversionService.ConvertAsync(exfat, blocked, Ps5ImageConversionTarget.ZArchive));
+            Check("the conversion fails instead of using the system drive", message?.Contains("temporary folder") == true);
+            Check("no output is written", !File.Exists(blocked));
+            message = await FailureOf(() => MetadataEditor.ApplyAsync(exfat, Path.Combine(outputs, "edited.exfat"), false,
+                new MetadataEdit { Title = "Temp QA" }, "00000000000000000000000000000000", string.Empty,
+                new Progress<PackageTaskProgress>(_ => { }), CancellationToken.None));
+            Check("editing details fails the same way", message?.Contains("temporary folder") == true);
+
+            Console.WriteLine("\n== a library scan while work files sit next to an output");
+            string job = Path.Combine(outputs, ".Packwright-convert-0123456789abcdef");
+            MakeDump(Path.Combine(job, "tree"));
+            File.Copy(exfat, Path.Combine(job, "image.exfat"));
+            var scan = await new Ps5LibraryScanner().ScanAsync([outputs], recursive: true);
+            Check("the real outputs are found", scan.Games.Any(game => game.RootPath.EndsWith("game.exfat", StringComparison.OrdinalIgnoreCase)));
+            Check("work folders are not listed as titles", !scan.Games.Any(game => game.RootPath.Contains(".Packwright-")));
+        }
+        finally
+        {
+            TemporaryFolders.Configure(null, nextToOutput: false);
+            try { Directory.Delete(work, true); } catch (IOException) { }
+        }
+        Console.WriteLine(_failures == 0 ? "\nALL PASSED" : $"\n{_failures} FAILED");
+        return _failures == 0 ? 0 : 1;
+    }
+
+    private static string MakeDump(string root)
+    {
+        Directory.CreateDirectory(Path.Combine(root, "sce_sys"));
+        Directory.CreateDirectory(Path.Combine(root, "data"));
+        File.WriteAllText(Path.Combine(root, "sce_sys", "param.json"),
+            """{"titleId":"PPSA99999","contentId":"UP9999-PPSA99999_00-TEMPFOLDERTEST00","localizedParameters":{"defaultLanguage":"en-US","en-US":{"titleName":"Temp Folder Test"}}}""");
+        var random = new Random(5);
+        foreach (int size in new[] { 1 << 20, 3 << 20, 4096 })
+        {
+            byte[] data = new byte[size];
+            random.NextBytes(data);
+            File.WriteAllBytes(Path.Combine(root, "data", $"file{size}.bin"), data);
+        }
+        return root;
+    }
+
+    private static bool NoJobFolders(string folder) => !Directory.Exists(folder) || !Directory.EnumerateDirectories(folder).Any();
+
+    private static async Task<string?> FailureOf(Func<Task> action)
+    {
+        try { await action(); return null; }
+        catch (IOException ex) { return ex.Message; }
+    }
+
+    private static void Check(string what, bool ok)
+    {
+        Console.WriteLine($"  {(ok ? "ok  " : "FAIL")} {what}");
+        if (!ok) _failures++;
+    }
+}