Merge pull request #440 from rbalsleyMSFT/UI

Update release notes and improve UI documentation and build process

ChangeLog.md

@@ -1,5 +1,368 @@
 # Change Log
 
+# 2603.2
+
+## What's Changed
+
+Highly recommended to upgrade to this release due to potential SecureBoot issues
+
+### Fixes SecureBoot-related boot issues on newly deployed FFUs
+
+Fixes an issue where some devices may not boot after an FFU was applied if the FFU was built from a machine that had been updated to the Windows UEFI CA 2023 SecureBoot certificates.
+
+Sometime at the start of this calendar year (Either January or February), a change was made in Windows to how BCDBoot functioned. If you took a CU from either of these months, BCDBoot will now check to see if the device has the 2011 or 2023 CA certificates. If 2023, the local BCDBoot will use the 2023 signed boot files when creating the System partition and these boot files will be deployed to the target system when the FFU is deployed. If the target machine hasn't updated to the 2023 certificates, boot will fail.
+
+To fix this, FFU Builder now uses the version of BCDBoot from the ADK instead of the locally installed version. The version of BCDBoot from the 10.1.26100.2454 ADK December 2024 version (which is what FFU Builder considers the latest), will provide the boot files signed with the 2011 certs.
+
+The version of [BCDBoot from the 10.1.28000.1 ADK](https://learn.microsoft.com/en-us/windows-hardware/get-started/what-s-new-in-kits-and-tools#bcd-boot) from November 2025 will default to using the 2023 certs as long as the machine supports the 2023 CA. This has been documented since this ADK was released. The behavior of this version of BCDBoot is what we're seeing now in devices that have been recently updated.
+
+I suspect that when 26H2 is released, there will be a new ADK around that time and at that point we'll move to using that version of the ADK, which that version of BCDBoot will default to using the 2023 signed boot files and I suspect WinPE will probably default to doing the same. By then, hopefully, most in-market devices should have the 2023 certificates in UEFI and those that don't will need to get the certs or downgrade their ADK version to use the 2011 signed boot files.
+
+### Fixes working directory handling
+
+Creation and deletion of the dirty.txt marker file now use an explicit path based on $FFUDevelopmentPath, avoiding ambiguity and potential issues with relative paths.
+
+**Full Changelog**: https://github.com/rbalsleyMSFT/FFU/compare/v2603.1...v2603.2
+
+# 2603.1
+
+## What's Changed
+
+### UI Out of Preview
+
+The UI is finally out of preview and the code from the UI branch has been pushed to main.
+
+### Remove old MSU files before servicing
+
+Fixes an issue where older cumulative update MSU files were mixed with newer files. In Windows 11 24H2, dism treats all MSU files in the same folder as possible update sources, causing servicing issues.
+
+This will primarily be an issue for those of you who use ISO files that don't have the latest updates, or those of you who create your FFUs with the ESD media shortly after patch Tuesday.
+
+### Adds OS-scoped update KB folders
+
+The KB folder where the CU and .NET updates downloads to will now have sub-folders for each Windows version. You may notice that if selecting 25H2, that the KB sub-folder for Windows 11 will show 24H2, this is to keep consistent with Windows 11 LTSC 2024 and Windows Server 2025, which all use the same 24H2 source OS (25H2 is just an eKB, not a full OS Swap Windows release like 24H2 was).
+
+### .NET Updates stored under their own dedicated KB folder
+
+This is more so to keep things clean, rather than fixing any sort of technical issue
+
+### Reworked Windows 10 LTSB\LTSC Cumulative Update Installation
+
+Since Windows 10 is out of support, offline servicing Windows 10 LTSC builds that are still supported fails due to extended security update requirements. The workaround to this is to install the updates in audit mode. FFU Builder now creates an Apps\LTSCUpdate folder and copies the LCU for Windows 10 LTSC builds still in support to the folder and installs the update in audit mode.
+
+### Fixes an issue with Update ADK failing for non-English languages
+
+Fixed a bug where updating the ADK would fail on non-English installations of Windows due to an assumption that the add/remove programs display information would be in English. Update ADK should correctly identify if the latest release of the ADK is installed and work as expected.
+
+### Added dependency validation when selecting Build USB drive and Copy Drivers
+
+Fixed an issue where a build would begin even though Copy Drivers to USB was set to true but no USB was inserted. FFU Builder will now check before the build gets started and inform the user if no USB drive is inserted.
+
+### Normalizes Windows LTSC release versions to handle driver downloads
+
+Driver downloads would fail if you were building certain LTSC releases due to FFU Builder incorrectly using the LTSC release year instead of the base Windows client version information. When build LTSC FFUs, the drivers should now download as expected.
+
+### Scopes select-all to visible filtered list items in drivers listview
+
+When filtering the drivers listview and selecting all driver models using the select all header checkbox, the select all behavior was selecting everything, even the hidden models in the list. If then selecting Download Selected, FFU Builder would download all models, even hidden ones. This now fixes that issue to only select all visible models and download those selected models.
+
+### Retain downloaded ESD files
+
+FFU Builder will now allow you to retain a downloaded ESD file. There's a new option on the Build tab to Remove Downloaded ESD File(s) which is checked by default to keep with the previous behavior. The intent here is to prevent from having to re-download the ESD file every time you're doing a build. This gives you another option along with Allow VHDX Caching to reduce the need of redownloading media.
+
+### Reduce the size of cached VHDX files
+
+Added some code to reduce the size of the cached VHDX files.
+
+### Include disk size in VHDX cache validation
+
+Prevents reusing cached images when the requested disk size changes. Ensures the disk size property is properly saved and verified against existing cache items to maintain configuration accuracy. This makes it so that if you create a new build with a larger disk size and have Allow VHDX caching selected, it won't use a cached VHDX with a smaller size.
+
+### Enhances file backup and cleanup for cancelled builds
+
+Improves the current-run cleanup mechanism by tracking file downloads explicitly. This ensures that files downloaded via BITS or preserving older timestamps are correctly identified and removed during cleanup. Extends the run manifest schema to support file backups, allowing for safe restoration of pre-existing scripts and configuration files modified during a run. Additional cleanup logic now correctly prunes residual empty directories after tracked files are removed.
+
+### Fixed an issue with arm64 ESD downloads
+
+With the change to how ESD downloads work with 25H2 and the Media Creation Tool, arm64 was broken. This was fixed.
+
+# 2602.1 UI Preview
+
+## What's Changed
+
+### Improved Automatic Matching for Surface devices
+
+To keep inline with HP, Dell, and Lenovo, added support for Surface devices to leverage the SystemSKU values from WMI when doing automatic driver matching during deployment. Check https://github.com/rbalsleyMSFT/FFU/pull/394 for more information. Long story short, there's a new `SurfaceDriverIndex.json` file that is created when getting the models which gathers the WMI information per model as well as the download links for each model. This info is used to generate the DriverMapping.json file for Surface to allow for better matching.
+
+There'll be deeper documentation on the new [docs site](https://rbalsleymsft.github.io/FFU/)
+
+### Improved driver injection error handling when deploying drivers via USB
+
+When drivers failed to be added from the USB drive during deployment, ApplyFFU.ps1 would fail with an error message and the deployment wouldn't complete. ApplyFFU.ps1 will now continue on failure and log the error and capture the setupapi.offline.log to the USB drive for troubleshooting if needed.
+
+### Fixed an issue with Windows image index for non-English media
+
+In some cases non-English media would cause the end-user to have to select which Windows SKU to select due to parsing the image name output and assuming the output was in English. BuildFFUVM.ps1 will now parse the edition metadata for each index. This should improve the experience for those that are creating FFUs from non-English media.
+
+### Run builds in separate pwsh process instead of background jobs
+
+In https://github.com/rbalsleyMSFT/FFU/pull/393, by changing the deprecated Get-WmiObject calls to Get-CimInstance, this actually broke console output. Still don't fully understand why GWMI was allowing background jobs to output console output to the calling pwsh Window but get-ciminstance wouldn't (WinRM, PowerShell Remoting, etc), but this required changing to running the build in a separate pwsh process. Between this and https://github.com/rbalsleyMSFT/FFU/pull/393, this should fix those that might build their FFUs on Servers and still expect to see console output.
+
+### Fixed an issue with USB drive selection for same-model USB drives
+
+When using the UI and selecting specific USB drives to create, the UI would allow you to select multiple of the same name, but would only create one of the drives. You should now be able to multi-select multiple USB drives with the same name and they should build as expected.
+
+### Created new docs site
+
+[FFU Builder docs](https://rbalsleymsft.github.io/FFU/) are now available! I'm still working on adding more documentation, but the layout of the site, the prereqs, quick start, and UI overview are done. I still have some stuff to migrate from the old docx file and some deep dive stuff to write up (Drivers, Apps, FAQs, Troubleshooting, etc). It should work well on both mobile and desktop. It also has built-in search capabilities to make it easy to find what you're interested in.
+
+## New Contributors
+
+* @JGehl99 made their first contribution in https://github.com/rbalsleyMSFT/FFU/pull/393
+
+**Full Changelog**: https://github.com/rbalsleyMSFT/FFU/compare/v2601.1Preview...v2602.1Preview
+
+# 2601.1 UI Preview
+
+## What's Changed
+
+### Improved WinPE driver copy reliability and logging
+
+Fixed a bug where some drivers weren't being copied into WinPE media when using **Use Drivers Folder as PE Drivers Source** option (`UseDriversAsPEDrivers` parameter)
+
+### Improved driver injection for long driver folder paths
+
+In some cases some drivers weren't being copied to the FFU or WinPE deployment media due to long paths. This required some significant refactoring. [See this post](https://github.com/rbalsleyMSFT/FFU/discussions/375) for more details on the changes that were made and the reasoning behind them.
+
+### Fixed an issue with WingetWin32Apps.Json file corruption during parallel app updates
+
+A code refactor that was done to consolidate some of the winget application download work that both the UI and BuildFFUVM.ps1 script caused an issue where parallel writes to the WingetWin32Apps.json file was causing the file to corrupt, resulting in apps not installing as expected.
+
+### Winget App installs now follow Applist.json order
+
+Winget application installs were installing in an indeterministic way when the WingetWin32Apps.json file was created. The order will now follow the order listed in the AppList.json file.
+
+### Support added for Winget Win32 app dependency handling
+
+Some apps (Camtasia) require dependency apps to be installed first. Winget will download said dependency apps. Dependent applications will now install before the calling application. There is also deduplication support added in the event multiple applications have the same dependencies.
+
+**Full Changelog**: [https://github.com/rbalsleyMSFT/FFU/compare/v2512.1Preview...v2601.1Preview](https://github.com/rbalsleyMSFT/FFU/compare/v2512.1Preview...v2601.1Preview)
+
+# 2512.1 UI Preview
+
+## What's Changed
+
+### Refactored Cleanup logic into a shared module
+
+Consolidates duplicated cleanup code by moving logic into a shared function, eliminating redundant implementations across multiple locations.
+
+Removes standalone cleanup functions (Remove-FFU, Remove-Apps, Remove-Updates) and replaces scattered cleanup calls with a single invocation of Invoke-FFUPostBuildCleanup.
+
+### Add 30 second delay to allow for Windows Security Platform to install
+
+There was an issue where the Windows Security Platform would attempt to install in the VM during the build via `Update-Defender.ps1` however the install didn't always happen and on deployment of the FFU, Windows Update would show that the Windows Security Platform needed an update. I suspect this is related to the AppxSVC not being ready during Audit Mode. Adding a 30 second delay appears to work more reliably.
+
+### Windows and .NET CU's now persist across builds
+
+Content in the FFUDevelopment\KB folder was always deleted once it was used. Since the Windows CU is so large now, it doesn't make sense to delete it if a user wants it again and may not be using cached VHDX files.
+
+Deletion of the KB folder is now correctly handled via the **Remove Downloaded Update Files** option on the Build tab.
+
+### Skip CU downloads if the Windows ESD version is current or newer
+
+Now that the Windows ESD media is kept up to date, there rarely will be a need to download the latest CU. There will always be a slight gap when the latest CU comes out and the updated media is available, but that's generally just a few days to a week.
+
+The script will now do some parsing of the windows version of the ESD file and the latest CU and if the ESD is newer, the CU will not be downloaded.
+
+### Fixes an issue with WingetWin32Apps.json file not being created if applications were pre-downloaded via the UI
+
+Fixed a bug due to some code consolidation that broke scenarios where applications that were downloaded via the UI, but were not installing in the VM.
+
+**Full Changelog**: https://github.com/rbalsleyMSFT/FFU/compare/v2511.1preview...v2511.2
+
+# 2511.1 UI Preview
+
+## What's Changed
+
+### Major changes to drivers
+
+A few weeks ago I wrote a [lengthy post](https://github.com/rbalsleyMSFT/FFU/discussions/350) asking for some help testing some changes that were added.
+
+The summary of that post is that there have been significant changes for both Dell and HP driver downloads to leverage the SystemID for each model. This increases the total number of driver models that are exposed in the UI. This also requires the `DriverMapping.json` to be modified to require the SystemID and query the SystemID from WMI when doing automatic matching.
+
+#### Driver folder structure changes on the USB drive - breaking change
+
+Driver folder structure on the USB drive has also changed. The new structure is `Drivers\Make\Model` (e.g. `D:\Drivers\Lenovo\Lenovo 300w`). This structure is consistent with how the UI and `BuildFFUVM.ps1` script download and store drivers and automatically copy them. So if you've been following that, then no changes are required.
+
+Please read [the post](https://github.com/rbalsleyMSFT/FFU/discussions/350) for more details on these changes to drivers.
+
+### Windows 11 25H2 is now the default option for MCT/ESD downloads
+
+For MCT/ESD downloads: Adds dynamic products.cab download functionality for Windows 11 using Windows Update service API instead of static MCT links. This is due to a change in how the MCT pulls the products.cab file. In other words, the Windows 11 25H2 ESD media is now updated each month (usually shortly after patch Tuesday)
+
+### Added 8 new hardware manufactures for automatic driver matching during deployment
+
+Extends hardware detection and driver mapping capabilities to support Panasonic, Viglen, AZW, Fujitsu, Getac, ByteSpeed, and Intel devices when applying the FFU to a device. This does not mean FFU Builder supports downloading drivers from these manufacturers. You'll still need to download the drivers for them manually. You can now create your own `DriverMapping.json` file to include these manufacturers.
+
+Thanks to @arwidmark and the [Modern Driver Management](https://msendpointmgr.com/modern-driver-management/) team for the WMI queries.
+
+### Fixed an issue with long paths when applying drivers from USB
+
+Implemented SUBST drive mappings to shorten driver file paths within WinPE as some paths were causing dism to error when servicing drivers. You should see a Z:\ drive when applying drivers from the USB drive.
+
+### Added an option to skip driver selection when multiple driver models are detected during deployment
+
+Allows users to bypass driver installation by entering 0 at the selection prompt, providing flexibility for deployments that don't require driver updates.
+
+### Add HTTP fallback for BITS transfer network authentication errors
+
+Fixes an issue with standard users elevating PowerShell as Admin and getting BITS errors when trying to download content.
+
+### Add -BitsPriority script parameter
+
+Introduces a new parameter `-BitsPriority` with options `(Foreground, High, Normal, Low)` to control BITS download priority across the build system and UI, allowing users to optimize transfer speeds when needed.
+
+The feature adds a priority selector to the UI with four options (Foreground, High, Normal, Low) and propagates the selection through the build script and common modules. Priority can be set via UI or command-line parameter with Normal as the default.
+
+### BYO Apps: Add MSI path quoting to handle spaces in msiexec arguments
+
+When specifying Build Your Own Apps msiexec arguments, if there were spaces in the argument list that weren't quoted properly, you'd get an error. This should now automatically add missing spaces in case you forget to add them or there are spaces in your application name.
+
+### Misc Fixes
+
+* Fixed some reliability issues when trying to download Lenovo drivers
+* Fixed an issue with PPKG files with spaces
+* Replaced SerialNumber with UniqueID for USB drive identification when building USB drives. USB drive manufacturers may use the same serial number for different drives, potentially causing data loss if the wrong drive is chosen.
+* `-Threads` parameter has been added to `BuildFFUVM.ps1` which defaults to 5, matching the UI behavior. This value can be 1-64.
+* ESD media downloads now use BITS by default
+* Fixed an issue with multi-disk devices. Prior, if multiple disks were detected, ApplyFFU.ps1 would fail. Now a menu pops up asking the end user to select the disk they want to deploy the FFU to
+
+## New Contributors
+
+* @arwidmark made their first contribution in https://github.com/rbalsleyMSFT/FFU/pull/325
+
+**Full Changelog**: https://github.com/rbalsleyMSFT/FFU/compare/v2509.1preview...v2511.1preview
+
+# 2509.1 UI Preview
+
+## What's Changed
+
+### [Refactor: Enhance artifact cleanup for disabled features](https://github.com/rbalsleyMSFT/FFU/commit/1ab4093d54b7d9bda9f47d7819694e66ae8de357)
+
+  Renames `Remove-DisabledUpdates` to `Remove-DisabledArtifacts` to better reflect its expanded scope.
+
+  This function now also removes Office installation scripts and downloaded content if the Office installation is disabled via the `$InstallOffice` flag.
+
+  The function call is moved to run before app installations to ensure artifacts are removed prior to the installation phase.
+
+### [Removes the VM workaround for MCT ESD builds](https://github.com/rbalsleyMSFT/FFU/commit/dc5877f398316969299ee03800f3d07c7d98a9ab)
+
+  Comments out the logic that forces app installation when building from a downloaded ESD file. This workaround was implemented to prevent an OOBE reboot loop but is no longer required. This should speed up scenarios where you want to download the ESD media, install the latest CU and .NET CU, and capture the FFU.
+
+### [Update default disk size to 50GB in FFU scripts and UI](https://github.com/rbalsleyMSFT/FFU/commit/372360d7392ad945be0db889a68e1fff0ed3b5d6)
+
+  Changed the default disk size parameter from 30GB to 50GB in BuildFFUVM.ps1 and FFUUI.Core.psm1 to accommodate larger virtual machines.
+  Updated tooltip and default value in the UI XAML file to reflect the new disk size.
+
+### [Adds auto-loading of previous configuration on startup](https://github.com/rbalsleyMSFT/FFU/commit/3ef26f2918977906ebe14e328f015ce4f1941dc3)
+
+Implements a new feature to automatically load the previously saved environment when the UI is launched.
+
+This improves user experience by restoring the last saved configuration, including selected applications and drivers, eliminating the need to manually reload them on each run.
+
+The process loads the main `FFUConfig.json` and then proceeds to load associated Winget, BYO App, and Driver lists if they are defined. UI elements and checkboxes are updated accordingly to reflect the loaded state.
+
+### [Improves UI state after environment autoload](https://github.com/rbalsleyMSFT/FFU/commit/bdf1b63833c83171aed63e8fc16702078ccd577b)
+
+Updates the visibility of UI panels for Winget and drivers when a previous environment is automatically loaded.
+
+This ensures that if Winget apps or driver models are present, their corresponding UI sections are made visible. Additionally, it updates the "select all" checkbox state for Winget results and attempts to pre-select the hardware make for loaded drivers.
+
+### [Add restore defaults and centralize cleanup logic](https://github.com/rbalsleyMSFT/FFU/commit/f3316a017b73bf12cf1a66e3d03a63e29c437cb1)
+
+Introduces a "Restore Defaults" feature in the UI to reset the environment. This action removes generated configuration files, ISOs, downloaded apps, updates, drivers, and FFUs.
+
+The post-build cleanup logic is refactored from the main build script into a new common function. This new function is used by both the standard build process and the new restore defaults feature, promoting code reuse and simplifying maintenance.
+
+### [Add option to dynamically build PE drivers](https://github.com/rbalsleyMSFT/FFU/commit/e2ccd11f07217b389f1622a69794224412e046e1)
+
+Thanks to @JonasKloseBW for the original code for this in https://github.com/rbalsleyMSFT/FFU/pull/115
+
+Introduces a new parameter, `UseDriversAsPEDrivers`, that allows WinPE drivers to be sourced directly from the main driver repository.
+
+When enabled, the script scans all available drivers, parses their INF files, and copies only the essential driver types (e.g., storage, mouse, keyboard, touchpad, system devices) needed for WinPE. This eliminates the need to maintain a separate, manually curated `PEDrivers` folder.
+
+The UI is updated with a new checkbox that becomes visible when "Copy PE Drivers" is selected, making this a sub-option. Parameter validation is also adjusted to support this new workflow.
+
+### [Improve model name normalization for driver mapping](https://github.com/rbalsleyMSFT/FFU/commit/50713188bffcb64f1b0c1f9eb89e02a300e3de98)
+
+Enhances the model name normalization function to better handle variations in hardware model strings. This change introduces specific rules to canonicalize "All-in-One" and screen size variants (e.g., "-in" or "inch") for more reliable matching against driver mapping rules.
+
+Additionally, optimizes performance by normalizing the system model once before the comparison loop. Logging is also added to show the original and normalized model strings for easier debugging.
+
+### [Defer cleanup of compressed driver source folders](https://github.com/rbalsleyMSFT/FFU/commit/c30ed923b68b933f719b9a2941043b813bf4fd3f)
+
+Implements a deferred cleanup mechanism for driver source folders when they are compressed to a WIM and also used for WinPE.
+
+When drivers are compressed, the original source folders are now preserved if they are also needed for WinPE driver injection. A marker file is created in these preserved folders.
+
+A new cleanup step is added after the WinPE media creation to remove these preserved folders, ensuring they are available when needed but not left behind permanently.
+
+### [Refactor config loading and improve error handling](https://github.com/rbalsleyMSFT/FFU/commit/8d7e4d106620761d0ae1a5133f6d6ba301131471)
+
+Extracts the logic for importing supplemental assets (Winget, BYO, Drivers) into a new reusable function. This function is now called by both the manual and automatic configuration loaders, reducing code duplication.
+
+Enhances the manual configuration loading process with more robust error handling. It now provides specific user-facing error messages for file read failures, empty files, and invalid JSON, improving the user experience when loading a malformed configuration.
+
+When loading a configuration, if optional supplemental files like AppList.json are referenced but not found, an informational message is now displayed to the user instead of failing silently.
+
+### [Add robust sanitization for names used in paths](https://github.com/rbalsleyMSFT/FFU/commit/cb14e84a26acaf5863aa3bb094dbf18424798875)
+
+Introduces a new common function, `ConvertTo-SafeName`, to sanitize strings by removing characters that are invalid in Windows file paths.
+
+This function is now used consistently when creating directory and file names for drivers (Dell, HP, Lenovo, Microsoft) and applications to prevent path-related errors. It replaces several ad-hoc sanitization methods with a single, more robust implementation.
+
+### [Includes exit code fields when using Copy Apps button](https://github.com/rbalsleyMSFT/FFU/commit/f37647599a318da29b62154bebff8c8a857d3002)
+
+Adds persistence of AdditionalExitCodes and IgnoreNonZeroExitCodes when exporting the UI list to prevent losing custom exit handling settings and maintain parity with the primary save routine.
+
+### [Sanitizes app names for storage and paths](https://github.com/rbalsleyMSFT/FFU/commit/d1ca1231045e38316733495e1fdb8590a225be67)
+
+Applies name sanitization when persisting the app list and when building/checking Win32 and Store download directories.
+Prevents invalid characters in folder names, aligns persisted names with on-disk structure, and improves detection of existing content to avoid redundant downloads and errors.
+
+### [Adds exit-code overrides and UI for winget apps](https://github.com/rbalsleyMSFT/FFU/commit/d9c0c9c68ee1769230c9789b5c7cb84bcff4d642)
+
+Adds per-app control for additional accepted exit codes and ignoring non‑zero exit codes to improve handling of installers with nonstandard returns.
+
+Exposes editable fields in the app list UI, persists them across search defaults, import/export, and pre-download save, and applies overrides during app resolution to honor configured behavior.
+
+### [Adds UI/CLI to copy additional FFUs to USB build](https://github.com/rbalsleyMSFT/FFU/commit/15a5b16b39887b71ae545c638d57183c97bdf629)
+
+- Enables selecting multiple existing FFU images to include on the deployment USB for easier distribution and testing.
+- Adds a UI option with selectable, sortable list from the capture folder, refresh support, and persisted selections.
+- Validates that selections exist when the option is enabled to prevent empty runs.
+- Supports unattended/CLI flows by prompting early or accepting a preselected list for USB creation; deduplicates and logs chosen files.
+- Always includes the just-built (or latest available) FFU as a base.
+- Improves no-FFU handling and streamlines multi-FFU selection workflow.
+
+### [Standardizes JSON output: depth, UTF-8, key order](https://github.com/rbalsleyMSFT/FFU/commit/6562d16ce500197b428b51915332c6649df302df)
+
+- Sorts top-level config keys before serialization for deterministic files and cleaner diffs.
+- Increases JSON depth to 10 to retain nested settings.
+- Writes JSON as UTF-8 via Set-Content for consistent encoding.
+- Applies across config export and UI save flows.
+
+### [Adds Windows 11 25H2 mapping](https://github.com/rbalsleyMSFT/FFU/commit/eaa3e1e6af5c25e0f8b185f8107e017782b0f00f)
+
+Extends supported Windows 11 releases to include 25H2. Default is still 24H2.
+
+* Update USBImagingToolCreator.ps1 by @jrollmann in https://github.com/rbalsleyMSFT/FFU/pull/262
+
+## New Contributors
+
+* @jrollmann made their first contribution in https://github.com/rbalsleyMSFT/FFU/pull/262
+
 # 2507.1 UI Preview
 
 Waaay too many to list. Just watch the Youtube video in the Readme :)

FFUDevelopment/Apps/Office/DownloadFFU.xml

@@ -2,16 +2,6 @@
   <Add SourcePath="C:\FFUDevelopment\Apps\Office" OfficeClientEdition="64" Channel="Current">
     <Product ID="O365ProPlusRetail">
       <Language ID="MatchOS" />
-      <ExcludeApp ID="Access" />
-      <ExcludeApp ID="Lync" />
-      <ExcludeApp ID="Publisher" />
-      <ExcludeApp ID="Bing" />
     </Product>
   </Add>
-  <Property Name="SharedComputerLicensing" Value="0" />
-  <Property Name="FORCEAPPSHUTDOWN" Value="FALSE" />
-  <Property Name="DeviceBasedLicensing" Value="0" />
-  <Property Name="SCLCacheOverride" Value="0" />
-  <Updates Enabled="TRUE" />
-  <Display Level="None" AcceptEULA="TRUE" />
 </Configuration>

FFUDevelopment/Apps/Orchestration/Install-Win32Apps.ps1

@@ -92,6 +92,49 @@ function Invoke-Process {
     }
 }
 
+function Format-MsiArguments {
+    <#
+    .SYNOPSIS
+        Ensures MSI file paths in msiexec arguments are properly quoted.
+    .DESCRIPTION
+        Detects /i arguments followed by an unquoted path ending in .msi
+        and wraps the path in double quotes to handle paths with spaces.
+    #>
+    param(
+        [Parameter(Mandatory)]
+        [string]$CommandLine,
+
+        [Parameter(Mandatory)]
+        [string]$Arguments
+    )
+
+    # Only process if the command is msiexec
+    if ($CommandLine -notmatch '^msiexec(\.exe)?$') {
+        return $Arguments
+    }
+
+    # Regex pattern explanation:
+    # (?i)            - Case-insensitive matching
+    # (/i)\s+         - Match /i followed by whitespace
+    # (?!")           - Negative lookahead: not already quoted
+    # (.+?\.msi)      - Capture path ending in .msi (lazy match to stop at first .msi)
+    # (?=\s+/|\s*$)   - Followed by another switch or end of string
+    
+    # Pattern to match /i followed by an unquoted MSI path
+    $pattern = '(?i)(/i)\s+(?!")(.+?\.msi)(?=\s+/|\s*$)'
+    
+    if ($Arguments -match $pattern) {
+        $originalArgs = $Arguments
+        # Replace with quoted path
+        $Arguments = $Arguments -replace $pattern, '$1 "$2"'
+        Write-Host "Detected unquoted MSI path in msiexec arguments. Adjusted arguments:"
+        Write-Host "Original: $originalArgs"
+        Write-Host "Modified: $Arguments"
+    }
+
+    return $Arguments
+}
+
 function Install-Applications {
     param(
         [Parameter(Mandatory)]
@@ -177,6 +220,15 @@ function Install-Applications {
                 $ignoreNonZeroExitCodes = $app.IgnoreNonZeroExitCodes
             }
 
+            # Auto-quote MSI paths if using msiexec and path contains spaces but no quotes
+            if ($null -ne $argumentsToPass -and $argumentsToPass.Count -gt 0) {
+                $joinedArgs = $argumentsToPass -join ' '
+                $formattedArgs = Format-MsiArguments -CommandLine $app.CommandLine -Arguments $joinedArgs
+                if ($formattedArgs -ne $joinedArgs) {
+                    $argumentsToPass = @($formattedArgs)
+                }
+            }
+
             if ($null -eq $argumentsToPass -or $argumentsToPass.Count -eq 0) {
                 Write-Host "Running command: $($app.CommandLine) (no arguments)"
                 $result = Invoke-Process -FilePath $app.CommandLine -AdditionalSuccessCodes $additionalSuccessCodes -IgnoreNonZeroExitCodes $ignoreNonZeroExitCodes

FFUDevelopment/Apps/Orchestration/Orchestrator.ps1

@@ -28,8 +28,9 @@ Write-Host "---------------------------------------------------" -ForegroundColo
 # Define the path to the scripts
 $scriptPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
 
-# Define the list of scripts to run, order doesn't matter - if you have a custom script, add it here
+# Define the list of scripts to run
 $scriptList = @(
+    "Install-LTSCUpdate.ps1",
     "Update-Defender.ps1",
     "Install-Office.ps1",
     "Update-MSRT.ps1",

FFUDevelopment/BuildFFUVM_UI.ps1

@@ -15,6 +15,7 @@
 
     This script acts as the primary host for the UI, connecting the user interface with the underlying build and logic modules.
 #>
+#Requires -RunAsAdministrator
 
 [CmdletBinding()]
 [System.STAThread()]
@@ -44,6 +45,7 @@ $script:uiState = [PSCustomObject]@{
         logData                     = $null;
         logStreamReader             = $null;
         pollTimer                   = $null;
+        currentBuildProcess         = $null;
         lastConfigFilePath          = $null
     };
     Flags              = @{
@@ -126,6 +128,14 @@ $window.Add_Loaded({
         Initialize-UIDefaults -State $script:uiState
         Initialize-DynamicUIElements -State $script:uiState
         Register-EventHandlers -State $script:uiState
+
+        # Attempt automatic load of previous environment (silent)
+        try {
+            Invoke-AutoLoadPreviousEnvironment -State $script:uiState
+        }
+        catch {
+            WriteLog "Auto-load previous environment failed: $($_.Exception.Message)"
+        }
     })
 
 
@@ -139,7 +149,7 @@ $script:uiState.Controls.btnRun.Add_Click({
             if ($script:uiState.Flags.isBuilding -and -not $script:uiState.Flags.isCleanupRunning) {
                 $btnRun.IsEnabled = $false
                 $script:uiState.Controls.txtStatus.Text = "Cancel requested. Stopping build..."
-                WriteLog "Cancel requested by user. Stopping background build job."
+                WriteLog "Cancel requested by user. Stopping background build process."
 
                 # Stop the timer
                 if ($null -ne $script:uiState.Data.pollTimer) {
@@ -154,92 +164,71 @@ $script:uiState.Controls.btnRun.Add_Click({
                     $script:uiState.Data.logStreamReader = $null
                 }
 
-                # Stop and remove the running build job
-                $jobToStop = $script:uiState.Data.currentBuildJob
-                $script:uiState.Data.currentBuildJob = $null
-                if ($null -ne $jobToStop) {
-                    try {
-                        # Attempt graceful stop first
-                        Stop-Job -Job $jobToStop -ErrorAction SilentlyContinue
-                        Wait-Job -Job $jobToStop -Timeout 5 -ErrorAction SilentlyContinue | Out-Null
-                    }
-                    catch {
-                        WriteLog "Stop-Job threw: $($_.Exception.Message)"
+                # Stop the running build process
+                $processToStop = $script:uiState.Data.currentBuildProcess
+                $script:uiState.Data.currentBuildProcess = $null
+
+                if ($null -ne $processToStop) {
+                    # Recursively terminate the build process and any children (DISM, setup tools, etc.)
+                    function Stop-ProcessTree {
+                        param([int]$parentPid)
+                        $children = Get-CimInstance Win32_Process -Filter "ParentProcessId=$parentPid" -ErrorAction SilentlyContinue
+                        foreach ($child in $children) {
+                            Stop-ProcessTree -parentPid $child.ProcessId
+                        }
+                        try { Stop-Process -Id $parentPid -Force -ErrorAction SilentlyContinue } catch {}
                     }
 
-                    # If the job's hosting process is still alive, kill its process tree to stop child tools like DISM
                     try {
-                        $jobProcId = $null
-                        if ($null -ne $jobToStop.ChildJobs -and $jobToStop.ChildJobs.Count -gt 0) {
-                            $jobProcId = $jobToStop.ChildJobs[0].ProcessId
-                        }
-                        if ($jobProcId) {
-                            # Recursively terminate the job process and any children
-                            function Stop-ProcessTree {
-                                param([int]$parentPid)
-                                $children = Get-CimInstance Win32_Process -Filter "ParentProcessId=$parentPid" -ErrorAction SilentlyContinue
-                                foreach ($child in $children) {
-                                    Stop-ProcessTree -parentPid $child.ProcessId
-                                }
-                                try { Stop-Process -Id $parentPid -Force -ErrorAction SilentlyContinue } catch {}
+                        Stop-ProcessTree -parentPid $processToStop.Id
+                        WriteLog "Background build process stopped (PID: $($processToStop.Id))."
+                    }
+                    catch {
+                        WriteLog "Error terminating build process tree: $($_.Exception.Message)"
+                    }
+                }
+
+                # Safety net: kill any active DISM capture still running
+                try {
+                    $dismCaptures = Get-CimInstance Win32_Process -Filter "Name='DISM.EXE'" -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -match '/Capture-FFU' }
+                    foreach ($p in $dismCaptures) {
+                        try { Stop-Process -Id $p.ProcessId -Force -ErrorAction SilentlyContinue } catch {}
+                    }
+                }
+                catch {
+                    WriteLog "Error stopping DISM capture processes: $($_.Exception.Message)"
+                }
+
+                # Also stop Office ODT setup.exe if running (to avoid recreating files after cleanup)
+                try {
+                    $officePathForKill = $null
+
+                    # Prefer explicit UI path
+                    $uiOfficePath = $script:uiState.Controls.txtOfficePath.Text
+                    if (-not [string]::IsNullOrWhiteSpace($uiOfficePath)) {
+                        $officePathForKill = $uiOfficePath
+                    }
+                    else {
+                        # Fall back to the last config path only if known
+                        $lastConfigPathLocal = $script:uiState.Data.lastConfigFilePath
+                        if (-not [string]::IsNullOrWhiteSpace($lastConfigPathLocal)) {
+                            $ffuDevRoot = Split-Path (Split-Path $lastConfigPathLocal -Parent) -Parent
+                            if (-not [string]::IsNullOrWhiteSpace($ffuDevRoot)) {
+                                $officePathForKill = Join-Path $ffuDevRoot 'Apps\Office'
                             }
-                            Stop-ProcessTree -parentPid $jobProcId
                         }
                     }
-                    catch {
-                        WriteLog "Error terminating job process tree: $($_.Exception.Message)"
-                    }
 
-                    # Safety net: kill any active DISM capture still running
-                    try {
-                        $dismCaptures = Get-CimInstance Win32_Process -Filter "Name='DISM.EXE'" -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -match '/Capture-FFU' }
-                        foreach ($p in $dismCaptures) {
+                    # Only proceed when a valid Office folder exists
+                    if ($officePathForKill -and (Test-Path -LiteralPath $officePathForKill -PathType Container)) {
+                        $setupProcs = Get-CimInstance Win32_Process -Filter "Name='setup.exe'" -ErrorAction SilentlyContinue | Where-Object { $_.ExecutablePath -like "$officePathForKill*" }
+                        foreach ($p in $setupProcs) {
                             try { Stop-Process -Id $p.ProcessId -Force -ErrorAction SilentlyContinue } catch {}
                         }
                     }
-                    catch {
-                        WriteLog "Error stopping DISM capture processes: $($_.Exception.Message)"
-                    }
-
-                    # Also stop Office ODT setup.exe if running (to avoid recreating files after cleanup)
-                    try {
-                        $officePathForKill = $null
-
-                        # Prefer explicit UI path
-                        $uiOfficePath = $script:uiState.Controls.txtOfficePath.Text
-                        if (-not [string]::IsNullOrWhiteSpace($uiOfficePath)) {
-                            $officePathForKill = $uiOfficePath
-                        }
-                        else {
-                            # Fall back to the last config path only if known
-                            $lastConfigPathLocal = $script:uiState.Data.lastConfigFilePath
-                            if (-not [string]::IsNullOrWhiteSpace($lastConfigPathLocal)) {
-                                $ffuDevRoot = Split-Path (Split-Path $lastConfigPathLocal -Parent) -Parent
-                                if (-not [string]::IsNullOrWhiteSpace($ffuDevRoot)) {
-                                    $officePathForKill = Join-Path $ffuDevRoot 'Apps\Office'
-                                }
-                            }
-                        }
-
-                        # Only proceed when a valid Office folder exists
-                        if ($officePathForKill -and (Test-Path -LiteralPath $officePathForKill -PathType Container)) {
-                            $setupProcs = Get-CimInstance Win32_Process -Filter "Name='setup.exe'" -ErrorAction SilentlyContinue | Where-Object { $_.ExecutablePath -like "$officePathForKill*" }
-                            foreach ($p in $setupProcs) {
-                                try { Stop-Process -Id $p.ProcessId -Force -ErrorAction SilentlyContinue } catch {}
-                            }
-                        }
-                    }
-                    catch {
-                        WriteLog "Error stopping Office setup.exe processes: $($_.Exception.Message)"
-                    }
-
-                    try {
-                        Remove-Job -Job $jobToStop -Force -ErrorAction SilentlyContinue
-                        WriteLog "Background build job stopped and removed."
-                    }
-                    catch {
-                        WriteLog "Error removing background build job: $($_.Exception.Message)"
-                    }
+                }
+                catch {
+                    WriteLog "Error stopping Office setup.exe processes: $($_.Exception.Message)"
                 }
 
                 # Start cleanup using the same BuildFFUVM.ps1 via -Cleanup short-circuit
@@ -280,13 +269,40 @@ $script:uiState.Controls.btnRun.Add_Click({
                     CleanupCurrentRunDownloads = $removeCurrentRunToo
                 }
 
-                $cleanupScriptBlock = {
-                    param($buildParams, $PSScriptRoot)
-                    & "$PSScriptRoot\BuildFFUVM.ps1" @buildParams
+                # Start cleanup in a separate pwsh process so the UI stays responsive
+                $pwshPath = Join-Path -Path $PSHOME -ChildPath 'pwsh.exe'
+                if (-not (Test-Path -Path $pwshPath)) {
+                    $pwshPath = 'pwsh'
                 }
 
-                # Start cleanup job
-                $script:uiState.Data.currentBuildJob = Start-Job -ScriptBlock $cleanupScriptBlock -ArgumentList @($cleanupParams, $PSScriptRoot)
+                $cleanupScriptPath = Join-Path -Path $PSScriptRoot -ChildPath 'BuildFFUVM.ps1'
+
+                # Build argument list for cleanup.
+                # -Cleanup is a [switch] in BuildFFUVM.ps1, so do not pass a value after it.
+                # Use -Param:$true/$false syntax for boolean parameters to avoid argument transformation errors.
+                $cleanupArgs = @(
+                    '-NoProfile',
+                    '-ExecutionPolicy', 'Bypass',
+                    '-File', $cleanupScriptPath,
+                    '-ConfigFile', $cleanupParams.ConfigFile,
+                    '-Cleanup',
+                    "-RemoveApps:$($cleanupParams.RemoveApps)",
+                    "-RemoveUpdates:$($cleanupParams.RemoveUpdates)",
+                    "-CleanupDrivers:$($cleanupParams.CleanupDrivers)",
+                    "-CleanupCurrentRunDownloads:$($cleanupParams.CleanupCurrentRunDownloads)"
+                )
+
+                $startCleanupParams = @{
+                    FilePath         = $pwshPath
+                    ArgumentList     = $cleanupArgs
+                    WorkingDirectory = $ffuDevPath
+                    PassThru         = $true
+                }
+                if ($Host.Name -eq 'ConsoleHost') {
+                    $startCleanupParams['NoNewWindow'] = $true
+                }
+
+                $script:uiState.Data.currentBuildProcess = Start-Process @startCleanupParams
 
                 # Wait for log file to appear (or open immediately if it exists)
                 $logWaitTimeout = 60
@@ -306,14 +322,14 @@ $script:uiState.Controls.btnRun.Add_Click({
                     WriteLog "Warning: Main log file not found at $mainLogPath after waiting. Monitor tab will not update during cleanup."
                 }
 
-                # Create a timer to poll the cleanup job
+                # Create a timer to poll the cleanup process
                 $script:uiState.Data.pollTimer = New-Object System.Windows.Threading.DispatcherTimer
                 $script:uiState.Data.pollTimer.Interval = [TimeSpan]::FromSeconds(1)
                 $script:uiState.Flags.isCleanupRunning = $true
 
                 $script:uiState.Data.pollTimer.Add_Tick({
                         param($sender, $e)
-                        $currentJob = $script:uiState.Data.currentBuildJob
+                        $currentProcess = $script:uiState.Data.currentBuildProcess
 
                         # Read new lines from log
                         if ($null -ne $script:uiState.Data.logStreamReader) {
@@ -326,13 +342,13 @@ $script:uiState.Controls.btnRun.Add_Click({
                             }
                         }
 
-                        if ($null -eq $currentJob -or $null -eq $script:uiState.Data.pollTimer) {
+                        if ($null -eq $currentProcess -or $null -eq $script:uiState.Data.pollTimer) {
                             if ($null -ne $sender) { $sender.Stop() }
                             $script:uiState.Data.pollTimer = $null
                             return
                         }
 
-                        if ($currentJob.State -in 'Completed', 'Failed', 'Stopped') {
+                        if ($currentProcess.HasExited) {
                             if ($null -ne $sender) { $sender.Stop() }
                             $script:uiState.Data.pollTimer = $null
 
@@ -355,10 +371,8 @@ $script:uiState.Controls.btnRun.Add_Click({
                             $script:uiState.Controls.pbOverallProgress.Visibility = 'Collapsed'
                             $script:uiState.Controls.pbOverallProgress.Value = 0
 
-                            # Receive and remove cleanup job
-                            $currentJob | Receive-Job -ErrorAction SilentlyContinue | Out-Null
-                            Remove-Job -Job $currentJob -Force
-                            $script:uiState.Data.currentBuildJob = $null
+                            # Clear cleanup process state
+                            $script:uiState.Data.currentBuildProcess = $null
 
                             # Reset flags and button
                             $script:uiState.Flags.isCleanupRunning = $false
@@ -392,8 +406,20 @@ $script:uiState.Controls.btnRun.Add_Click({
             
             # Gather config on the UI thread before starting the job
             $config = Get-UIConfig -State $script:uiState
+
+            # Validate Additional FFU selection if enabled
+            if ($config.BuildUSBDrive -and $config.CopyAdditionalFFUFiles -and (($null -eq $config.AdditionalFFUFiles) -or ($config.AdditionalFFUFiles.Count -eq 0))) {
+                [System.Windows.MessageBox]::Show("Please select at least one additional FFU file to copy, or uncheck 'Copy Additional FFU Files'.", "Selection Required", "OK", "Warning") | Out-Null
+                $btnRun.IsEnabled = $true
+                $script:uiState.Controls.txtStatus.Text = "Build canceled: Additional FFU selection required."
+                return
+            }
+
             $configFilePath = Join-Path $config.FFUDevelopmentPath "\config\FFUConfig.json"
-            $config | ConvertTo-Json -Depth 10 | Set-Content -Path $configFilePath -Encoding UTF8
+            # Sort top-level keys alphabetically for consistent output
+            $sortedConfig = [ordered]@{}
+            foreach ($k in ($config.Keys | Sort-Object)) { $sortedConfig[$k] = $config[$k] }
+            $sortedConfig | ConvertTo-Json -Depth 10 | Set-Content -Path $configFilePath -Encoding UTF8
             $script:uiState.Data.lastConfigFilePath = $configFilePath
             
             if ($config.InstallOffice -and $config.OfficeConfigXMLFile) {
@@ -404,33 +430,45 @@ $script:uiState.Controls.btnRun.Add_Click({
             $txtStatus.Text = "Executing BuildFFUVM.ps1 in the background..."
             WriteLog "Executing BuildFFUVM.ps1 in the background..."
 
-            # Prepare parameters for splatting
-            $buildParams = @{
-                ConfigFile = $configFilePath
+            # Start BuildFFUVM.ps1 in a separate pwsh process.
+            # This keeps the UI responsive and restores console interaction (Write-Host / Read-Host) when available.
+            $pwshPath = Join-Path -Path $PSHOME -ChildPath 'pwsh.exe'
+            if (-not (Test-Path -Path $pwshPath)) {
+                $pwshPath = 'pwsh'
             }
+
+            $buildScriptPath = Join-Path -Path $PSScriptRoot -ChildPath 'BuildFFUVM.ps1'
+            $pwshArgs = @(
+                '-NoProfile',
+                '-ExecutionPolicy', 'Bypass',
+                '-File', $buildScriptPath,
+                '-ConfigFile', $configFilePath
+            )
             if ($config.Verbose) {
-                $buildParams['Verbose'] = $true
+                $pwshArgs += '-Verbose'
             }
 
-            # Define the script block to run in the background job
-            $scriptBlock = {
-                param($buildParams, $PSScriptRoot)
-                
-                # This script runs in a new process. BuildFFUVM.ps1 is expected to handle its own module imports.
-                & "$PSScriptRoot\BuildFFUVM.ps1" @buildParams
-            }
-
-            # Delete the old log file before starting the build job to ensure we don't read stale content.
+            # Delete the old log file before starting the build process to ensure we don't read stale content.
             $mainLogPath = Join-Path $config.FFUDevelopmentPath "FFUDevelopment.log"
             if (Test-Path $mainLogPath) {
                 WriteLog "Removing old FFUDevelopment.log file."
                 Remove-Item -Path $mainLogPath -Force
             }
 
-            # Start the job and store it in the shared state object
-            $script:uiState.Data.currentBuildJob = Start-Job -ScriptBlock $scriptBlock -ArgumentList @($buildParams, $PSScriptRoot)
+            $startBuildParams = @{
+                FilePath         = $pwshPath
+                ArgumentList     = $pwshArgs
+                WorkingDirectory = $config.FFUDevelopmentPath
+                PassThru         = $true
+            }
+            if ($Host.Name -eq 'ConsoleHost') {
+                $startBuildParams['NoNewWindow'] = $true
+            }
 
-            # Wait for the new log file to be created by the background job.
+            # Start the build process and store it in the shared state object
+            $script:uiState.Data.currentBuildProcess = Start-Process @startBuildParams
+
+            # Wait for the new log file to be created by the background process.
             $logWaitTimeout = 15 # seconds
             $watch = [System.Diagnostics.Stopwatch]::StartNew()
             while (-not (Test-Path $mainLogPath) -and $watch.Elapsed.TotalSeconds -lt $logWaitTimeout) {
@@ -455,7 +493,7 @@ $script:uiState.Controls.btnRun.Add_Click({
             $script:uiState.Data.pollTimer.Add_Tick({
                     param($sender, $e)
                     # This scriptblock runs on the UI thread, so it can safely access script-scoped variables
-                    $currentJob = $script:uiState.Data.currentBuildJob
+                    $currentProcess = $script:uiState.Data.currentBuildProcess
                     
                     # Read from log stream
                     if ($null -ne $script:uiState.Data.logStreamReader) {
@@ -479,8 +517,8 @@ $script:uiState.Controls.btnRun.Add_Click({
                         }
                     }
 
-                    # If job is somehow null or the timer has been nulled out, stop the timer
-                    if ($null -eq $currentJob -or $null -eq $script:uiState.Data.pollTimer) {
+                    # If process is somehow null or the timer has been nulled out, stop the timer
+                    if ($null -eq $currentProcess -or $null -eq $script:uiState.Data.pollTimer) {
                         if ($null -ne $sender) {
                             $sender.Stop()
                         }
@@ -488,8 +526,8 @@ $script:uiState.Controls.btnRun.Add_Click({
                         return
                     }
 
-                    # Check if the job has reached a terminal state
-                    if ($currentJob.State -in 'Completed', 'Failed', 'Stopped') {
+                    # Check if the build process has exited
+                    if ($currentProcess.HasExited) {
                         # Stop the timer, we're done polling
                         if ($null -ne $sender) {
                             $sender.Stop()
@@ -525,42 +563,26 @@ $script:uiState.Controls.btnRun.Add_Click({
                             $script:uiState.Data.logStreamReader = $null
                         }
 
-                        # Determine final status based on job result and whether cleanup was running (should be false here)
+                        $exitCode = $currentProcess.ExitCode
+
+                        # Determine final status based on process exit code
                         $finalStatusText = "FFU build completed successfully."
-                        if ($currentJob.State -eq 'Failed') {
-                            $reason = $null
-                            
-                            Receive-Job -Job $currentJob -Keep -ErrorVariable jobErrors -ErrorAction SilentlyContinue | Out-Null
-                            
-                            if ($null -ne $jobErrors -and $jobErrors.Count -gt 0) {
-                                $reason = ($jobErrors | Select-Object -Last 1).ToString()
-                            }
-
-                            if ([string]::IsNullOrWhiteSpace($reason) -and $currentJob.JobStateInfo.Reason) {
-                                $reason = $currentJob.JobStateInfo.Reason.Message
-                            }
-
-                            if ([string]::IsNullOrWhiteSpace($reason)) {
-                                $reason = "An unknown error occurred. The job failed without a specific reason."
-                            }
-
+                        if ($exitCode -ne 0) {
                             $finalStatusText = "FFU build failed. Check FFUDevelopment.log for details."
-                            WriteLog "BuildFFUVM.ps1 job failed. Reason: $reason"
-                            [System.Windows.MessageBox]::Show("The build process failed. Please check the $FFUDevelopmentPath\FFUDevelopment.log file for details.`n`nError: $reason", "Build Error", "OK", "Error") | Out-Null
+                            WriteLog "BuildFFUVM.ps1 process failed with exit code: $exitCode"
+                            [System.Windows.MessageBox]::Show("The build process failed. Please check the $FFUDevelopmentPath\FFUDevelopment.log file for details.`n`nExit code: $exitCode", "Build Error", "OK", "Error") | Out-Null
                             $script:uiState.Controls.pbOverallProgress.Visibility = 'Collapsed'
                         }
                         else {
-                            WriteLog "BuildFFUVM.ps1 job completed successfully."
+                            WriteLog "BuildFFUVM.ps1 process completed successfully."
                             $script:uiState.Controls.pbOverallProgress.Value = 100
                         }
 
                         # Update UI elements
                         $script:uiState.Controls.txtStatus.Text = $finalStatusText
 
-                        # Receive & remove job and clear state
-                        $currentJob | Receive-Job -ErrorAction SilentlyContinue | Out-Null
-                        Remove-Job -Job $currentJob -Force
-                        $script:uiState.Data.currentBuildJob = $null
+                        # Clear process state
+                        $script:uiState.Data.currentBuildProcess = $null
 
                         # Reset button and flags for next run
                         $script:uiState.Flags.isBuilding = $false
@@ -619,9 +641,9 @@ $window.Add_SourceInitialized({
 
 # Register cleanup to reclaim memory and revert LongPathsEnabled setting when the UI window closes
 $window.Add_Closed({
-        # Stop any running build job if the window is closed
-        if ($null -ne $script:uiState.Data.currentBuildJob) {
-            WriteLog "UI closing, stopping background build job."
+        # Stop any running build process if the window is closed
+        if ($null -ne $script:uiState.Data.currentBuildProcess) {
+            WriteLog "UI closing, stopping background build process."
             
             # Stop the timer
             if ($null -ne $script:uiState.Data.pollTimer) {
@@ -636,17 +658,28 @@ $window.Add_Closed({
                 $script:uiState.Data.logStreamReader = $null
             }
 
-            # Stop and remove the job
-            $jobToStop = $script:uiState.Data.currentBuildJob
-            $script:uiState.Data.currentBuildJob = $null # Clear it from state first
+            $processToStop = $script:uiState.Data.currentBuildProcess
+            $script:uiState.Data.currentBuildProcess = $null
 
             try {
-                Stop-Job -Job $jobToStop
-                Remove-Job -Job $jobToStop
-                WriteLog "Background job stopped and removed."
+                # Terminate the build process and any children
+                function Stop-ProcessTree {
+                    param([int]$parentPid)
+                    $children = Get-CimInstance Win32_Process -Filter "ParentProcessId=$parentPid" -ErrorAction SilentlyContinue
+                    foreach ($child in $children) {
+                        Stop-ProcessTree -parentPid $child.ProcessId
+                    }
+                    try { Stop-Process -Id $parentPid -Force -ErrorAction SilentlyContinue } catch {}
+                }
+
+                if ($null -ne $processToStop -and -not $processToStop.HasExited) {
+                    Stop-ProcessTree -parentPid $processToStop.Id
+                }
+
+                WriteLog "Background process stopped."
             }
             catch {
-                WriteLog "Error stopping or removing background job: $($_.Exception.Message)"
+                WriteLog "Error stopping background build process: $($_.Exception.Message)"
             }
         }
 

FFUDevelopment/BuildFFUVM_UI.xaml

@@ -115,9 +115,9 @@
                         <TextBox x:Name="txtVMHostIPAddress" Grid.Row="2" Grid.Column="1" Margin="5" VerticalAlignment="Center" HorizontalAlignment="Stretch"/>
                         <!-- Row 3: Disk Size (GB) -->
                         <StackPanel Grid.Row="3" Grid.Column="0" Orientation="Horizontal" VerticalAlignment="Center" Margin="0,5">
-                            <TextBlock Text="Disk Size (GB)" ToolTip="Size of the virtual hard disk for the virtual machine. Default is a 30GB dynamic disk."/>
+                            <TextBlock Text="Disk Size (GB)" ToolTip="Size of the virtual hard disk for the virtual machine. Default is a 50GB dynamic disk."/>
                         </StackPanel>
-                        <TextBox x:Name="txtDiskSize" Grid.Row="3" Grid.Column="1" Margin="5" VerticalAlignment="Center" HorizontalAlignment="Stretch" Text="30" ToolTip="Size of the virtual hard disk for the virtual machine. Default is a 30GB dynamic disk."/>
+                        <TextBox x:Name="txtDiskSize" Grid.Row="3" Grid.Column="1" Margin="5" VerticalAlignment="Center" HorizontalAlignment="Stretch" Text="50" ToolTip="Size of the virtual hard disk for the virtual machine. Default is a 50GB dynamic disk."/>
                         <!-- Row 4: Memory (GB) -->
                         <StackPanel Grid.Row="4" Grid.Column="0" Orientation="Horizontal" VerticalAlignment="Center" Margin="0,5">
                             <TextBlock Text="Memory (GB)" ToolTip="Amount of memory to allocate for the virtual machine. Recommended to use 8GB if possible, especially for Windows 11. Default is 4GB."/>
@@ -359,7 +359,7 @@
 
                                 <!-- Arguments -->
                                 <TextBlock Text="Arguments:" Margin="0,0,0,5"/>
-                                <TextBox x:Name="txtAppArguments" Margin="0,0,0,10" ToolTip="Enter the arguments for the command line. If the application is an msi, the command line should only contain msiexec and the rest of the command line arguments would go here (e.g. /i D:\Win32\Mozilla firefox\setup.msi /qn /norestart)."/>
+                                <TextBox x:Name="txtAppArguments" Margin="0,0,0,10" ToolTip="Enter the arguments for the command line. If the application is an msi, the command line should only contain msiexec and the rest of the command line arguments would go here (e.g. /i &quot;D:\Win32\Mozilla firefox\setup.msi&quot; /qn /norestart)."/>
 
                                 <!-- Source -->
                                 <TextBlock Text="Source:" Margin="0,0,0,5"/>
@@ -628,9 +628,10 @@
                             <CheckBox x:Name="chkCompressDriversToWIM" Content="Compress Driver Model Folder to WIM" Margin="0,0,5,0" ToolTip="When set to $true, will compress each downloaded driver model folder into a separate WIM file within the Drivers folder. This is useful with Copy Drivers to USB drive."/>
                         </StackPanel>
 
-                        <!-- Row 12: Copy PE Drivers Checkbox -->
-                        <StackPanel Grid.Row="12" Orientation="Horizontal" Margin="5">
-                            <CheckBox x:Name="chkCopyPEDrivers" Content="Copy PE Drivers" Margin="0,0,5,0" ToolTip="When set to $true, will copy the drivers from the $FFUDevelopmentPath\PEDrivers folder to the WinPE deployment media. Default is $false."/>
+                        <!-- Row 12: PE Driver Options (UseDriversAsPEDrivers is a dependent sub-option) -->
+                        <StackPanel Grid.Row="12" Margin="5">
+                            <CheckBox x:Name="chkCopyPEDrivers" Content="Copy PE Drivers" Margin="0,0,0,5" ToolTip="When set to $true, will copy the drivers from the $FFUDevelopmentPath\PEDrivers folder to the WinPE deployment media. Default is $false."/>
+                            <CheckBox x:Name="chkUseDriversAsPEDrivers" Content="Use Drivers Folder as PE Drivers Source" Margin="25,0,0,0" Visibility="Collapsed" ToolTip="When set to $true (and Copy PE Drivers is also checked), bypasses the PE Drivers Folder path and instead scans the Drivers folder to gather only required WinPE drivers. Hidden unless Copy PE Drivers is checked."/>
                         </StackPanel>
                     </Grid>
                 </ScrollViewer>
@@ -640,7 +641,7 @@
             <TabItem Header="Build" Padding="20">
                 <ScrollViewer VerticalScrollBarVisibility="Auto">
                     <Grid Margin="10">
-                        <!-- Define 10 rows for the Build tab -->
+                        <!-- Define 12 rows for the Build tab -->
                         <Grid.RowDefinitions>
                             <!-- Row 0: Header -->
                             <RowDefinition Height="Auto"/>
@@ -656,13 +657,15 @@
                             <RowDefinition Height="Auto"/>
                             <!-- Row 6: Threads -->
                             <RowDefinition Height="Auto"/>
-                            <!-- Row 7: General Build Options Header -->
+                            <!-- Row 7: BITS Priority -->
                             <RowDefinition Height="Auto"/>
-                            <!-- Row 8: General Build Options Checkboxes -->
+                            <!-- Row 8: General Build Options Header -->
                             <RowDefinition Height="Auto"/>
-                            <!-- Row 9: Build USB Drive Section -->
+                            <!-- Row 9: General Build Options Checkboxes -->
                             <RowDefinition Height="Auto"/>
-                            <!-- Row 10: Post-Build Cleanup -->
+                            <!-- Row 10: Build USB Drive Section -->
+                            <RowDefinition Height="Auto"/>
+                            <!-- Row 11: Post-Build Cleanup -->
                             <RowDefinition Height="Auto"/>
                         </Grid.RowDefinitions>
                         <Grid.ColumnDefinitions>
@@ -728,11 +731,25 @@
                             <TextBlock Grid.Column="0" Text="Threads" VerticalAlignment="Center" ToolTip="Controls the number of parallel threads used by ForEach-Object -Parallel and sets the value of the -ThrottleLimit parameter. Default is 5. Used in Winget, Application Copy, and driver downloads"/>
                             <TextBox x:Name="txtThreads" Grid.Column="1" Margin="5" VerticalAlignment="Center" Width="50" HorizontalAlignment="Left" Text="5" ToolTip="Controls the number of parallel threads used by ForEach-Object -Parallel and sets the value of the -ThrottleLimit parameter. Default is 5. Used in Winget, Application Copy, and driver downloads"/>
                         </Grid>
-                        <!-- Row 7: General Build Options Header -->
-                        <TextBlock Grid.Row="7" Text="General Build Options" FontWeight="Bold" FontSize="16" Margin="0,10,0,5"/>
+                        <!-- Row 7: BITS Priority -->
+                        <Grid Grid.Row="7" Margin="0,5">
+                            <Grid.ColumnDefinitions>
+                                <ColumnDefinition Width="200"/>
+                                <ColumnDefinition Width="*"/>
+                            </Grid.ColumnDefinitions>
+                            <TextBlock Grid.Column="0" Text="BITS Priority" VerticalAlignment="Center" ToolTip="Controls the BITS download priority used by the UI and BuildFFUVM.ps1. Switch to Foreground to maximize download speed if needed."/>
+                            <ComboBox x:Name="cmbBitsPriority" Grid.Column="1" Margin="5" VerticalAlignment="Center" Width="150" HorizontalAlignment="Left" ToolTip="Controls the BITS download priority used by the UI and BuildFFUVM.ps1. Switch to Foreground to maximize download speed if needed.">
+                                <sys:String>Foreground</sys:String>
+                                <sys:String>High</sys:String>
+                                <sys:String>Normal</sys:String>
+                                <sys:String>Low</sys:String>
+                            </ComboBox>
+                        </Grid>
+                        <!-- Row 8: General Build Options Header -->
+                        <TextBlock Grid.Row="8" Text="General Build Options" FontWeight="Bold" FontSize="16" Margin="0,10,0,5"/>
 
-                        <!-- Row 8: General Build Options Checkboxes -->
-                        <WrapPanel Grid.Row="8" Margin="0,5">
+                        <!-- Row 9: General Build Options Checkboxes -->
+                        <WrapPanel Grid.Row="9" Margin="0,5">
                             <CheckBox x:Name="chkBuildUSBDriveEnable" Content="Build USB Drive" Margin="5" VerticalAlignment="Center" Tag="When set to $true, will partition and format a USB drive and copy the captured FFU to the drive."/>
                             <CheckBox x:Name="chkCompactOS" Content="Compact OS" Margin="5" VerticalAlignment="Center" Tag="When set to $true, will compact the OS when building the FFU."/>
                             <CheckBox x:Name="chkUpdateADK" Content="Update ADK" Margin="5" VerticalAlignment="Center" Tag="When set to $true, the script will check for and install/update to the latest Windows ADK and WinPE add-on."/>
@@ -744,8 +761,8 @@
                             <CheckBox x:Name="chkVerbose" Content="Verbose" Margin="5" VerticalAlignment="Center" Tag="When set to $true, will enable write-verbose output to the console for the build script."/>
                         </WrapPanel>
 
-                        <!-- Row 9: Build USB Drive Section -->
-                        <StackPanel Grid.Row="9" Margin="0,10,0,5" x:Name="usbDriveSection" Visibility="Collapsed">
+                        <!-- Row 10: Build USB Drive Section -->
+                        <StackPanel Grid.Row="10" Margin="0,10,0,5" x:Name="usbDriveSection" Visibility="Collapsed">
                             <TextBlock Text="Build USB Drive Settings" FontWeight="Bold" FontSize="16" Margin="0,0,0,10"/>
                             <StackPanel Margin="5,0,0,10">
                                 <CheckBox x:Name="chkAllowExternalHardDiskMedia" Content="Allow External Hard Disk Media" Margin="5" VerticalAlignment="Center" Tag="When set to $true, will allow the use of external hard disk media."/>
@@ -755,6 +772,29 @@
                                 <CheckBox x:Name="chkCopyAutopilot" Content="Copy Autopilot Profile" Margin="5" VerticalAlignment="Center" Tag="When set to $true, will copy the Autopilot profile to the USB drive."/>
                                 <CheckBox x:Name="chkCopyUnattend" Content="Copy Unattend.xml" Margin="5" VerticalAlignment="Center" Tag="When set to $true, will copy the Unattend.xml file to the USB drive."/>
                                 <CheckBox x:Name="chkCopyPPKG" Content="Copy Provisioning Package" Margin="5" VerticalAlignment="Center" Tag="When set to $true, will copy the provisioning package to the USB drive."/>
+                                <CheckBox x:Name="chkCopyAdditionalFFUFiles" Content="Copy Additional FFU Files" Margin="5" VerticalAlignment="Center" Tag="When set to $true, allows selecting existing FFU files in the capture folder to also copy to the USB drive."/>
+
+                                <!-- Additional FFU Selection Section -->
+                                <Grid x:Name="additionalFFUPanel" Margin="5,0,0,10" Visibility="Collapsed">
+                                    <Grid.RowDefinitions>
+                                        <RowDefinition Height="Auto"/>
+                                        <RowDefinition Height="*"/>
+                                    </Grid.RowDefinitions>
+                                    <!-- Header row -->
+                                    <DockPanel Grid.Row="0" Margin="0,5" LastChildFill="False">
+                                        <TextBlock Text="Additional FFU Files" DockPanel.Dock="Left" FontWeight="Bold" VerticalAlignment="Center" Margin="0,0,10,0"/>
+                                        <Button x:Name="btnRefreshAdditionalFFUs" Content="Refresh" DockPanel.Dock="Left" Padding="10,5" ToolTip="Refresh the list of FFU files from the capture folder"/>
+                                    </DockPanel>
+                                    <!-- ListView row -->
+                                    <ListView x:Name="lstAdditionalFFUs" Grid.Row="1" Margin="0,5" Height="150">
+                                        <ListView.View>
+                                            <GridView>
+                                                <GridViewColumn Header="FFU Name" DisplayMemberBinding="{Binding Name}" Width="300"/>
+                                                <GridViewColumn Header="Last Modified" DisplayMemberBinding="{Binding LastModified}" Width="200"/>
+                                            </GridView>
+                                        </ListView.View>
+                                    </ListView>
+                                </Grid>
 
                                 <!-- Max USB Drives -->
                                 <StackPanel Orientation="Horizontal" Margin="5">
@@ -778,7 +818,7 @@
                                             <GridView>
 
                                                 <GridViewColumn Header="Model" DisplayMemberBinding="{Binding Model}" Width="200"/>
-                                                <GridViewColumn Header="Serial Number" DisplayMemberBinding="{Binding SerialNumber}" Width="150"/>
+                                                <GridViewColumn Header="Unique ID" DisplayMemberBinding="{Binding UniqueId}" Width="300"/>
                                                 <GridViewColumn Header="Size (GB)" DisplayMemberBinding="{Binding Size}" Width="80"/>
                                             </GridView>
                                         </ListView.View>
@@ -787,8 +827,8 @@
                             </StackPanel>
                         </StackPanel>
 
-                        <!-- Row 10: Post-Build Cleanup -->
-                        <StackPanel Grid.Row="10" Margin="0,10,0,5">
+                        <!-- Row 11: Post-Build Cleanup -->
+                        <StackPanel Grid.Row="11" Margin="0,10,0,5">
                             <TextBlock Text="Post-Build Cleanup" FontWeight="Bold" FontSize="16" Margin="0,0,0,5"/>
                             <CheckBox x:Name="chkCleanupAppsISO" Content="Cleanup Apps ISO" Margin="5" VerticalAlignment="Center" Tag="Remove Apps ISO after FFU capture."/>
                             <CheckBox x:Name="chkCleanupCaptureISO" Content="Cleanup Capture ISO" Margin="5" VerticalAlignment="Center" Tag="Remove WinPE capture ISO after FFU capture."/>
@@ -797,6 +837,7 @@
                             <CheckBox x:Name="chkRemoveFFU" Content="Remove FFU" Margin="5" VerticalAlignment="Center" Tag="Remove FFU after copying to USB drive."/>
                             <CheckBox x:Name="chkRemoveApps" Content="Remove Apps Folder Content" Margin="5" VerticalAlignment="Center" Tag="When set to $true, will remove the application content in the Apps folder after the FFU has been captured."/>
                             <CheckBox x:Name="chkRemoveUpdates" Content="Remove Downloaded Update Files" Margin="5" VerticalAlignment="Center" Tag="When set to $true, will remove downloaded CU, .NET, MSRT, Defender, Edge, and OneDrive files after being applied/included."/>
+                            <CheckBox x:Name="chkRemoveDownloadedESD" Content="Remove Downloaded ESD file(s)" Margin="5" VerticalAlignment="Center" Tag="When set to $true, will remove downloaded Windows ESD file(s) after they are used."/>
                         </StackPanel>
                     </Grid>
                 </ScrollViewer>
@@ -816,6 +857,7 @@
         <TextBlock x:Name="txtStatus" Grid.Row="2" Margin="0,5,0,0"/>
         <!-- Buttons (Build Config File / Load Config File / Build FFU) -->
         <StackPanel Grid.Row="3" Orientation="Horizontal" HorizontalAlignment="Right" Margin="0,0,20,20">
+            <Button x:Name="btnRestoreDefaults" Content="Restore Defaults" Width="150" Margin="0,0,10,0" FontSize="14" Padding="10,5"/>
             <Button x:Name="btnBuildConfig" Content="Save Config File" Width="150" Margin="0,0,10,0" FontSize="14" Padding="10,5"/>
             <Button x:Name="btnLoadConfig" Content="Load Config File" Width="150" Margin="0,0,10,0" FontSize="14" Padding="10,5"/>
             <Button x:Name="btnRun" Content="Build FFU" Width="120" FontSize="14" Padding="10,5"/>

FFUDevelopment/FFU.Common/FFU.Common.Cleanup.psm1

@@ -0,0 +1,151 @@
+# Provides shared cleanup functionality for both UI and build script.
+
+function Invoke-FFUPostBuildCleanup {
+    param(
+        [string]$RootPath,
+        [string]$AppsPath,
+        [string]$DriversPath,
+        [string]$FFUCapturePath,
+        [string]$CaptureISOPath,
+        [string]$DeployISOPath,
+        [string]$AppsISOPath,
+        [string]$KBPath,
+        [bool]$RemoveCaptureISO = $false,
+        [bool]$RemoveDeployISO = $false,
+        [bool]$RemoveAppsISO = $false,
+        [bool]$RemoveDrivers = $false,
+        [bool]$RemoveFFU = $false,
+        [bool]$RemoveApps = $false,
+        [bool]$RemoveUpdates = $false,
+        [bool]$RemoveDownloadedESD = $false
+    )
+    $originalProgressPreference = $ProgressPreference
+    $ProgressPreference = 'SilentlyContinue'
+    try {
+        WriteLog "CommonCleanup: Starting cleanup (CaptureISO=$RemoveCaptureISO DeployISO=$RemoveDeployISO AppsISO=$RemoveAppsISO Drivers=$RemoveDrivers FFU=$RemoveFFU Apps=$RemoveApps Updates=$RemoveUpdates RemoveDownloadedESD=$RemoveDownloadedESD KBPath=$KBPath)."
+
+        # Primary ISO paths (new naming/location)
+        if ($RemoveCaptureISO -and -not [string]::IsNullOrWhiteSpace($CaptureISOPath) -and (Test-Path -LiteralPath $CaptureISOPath)) {
+            WriteLog "CommonCleanup: Removing $CaptureISOPath"
+            try { Remove-Item -LiteralPath $CaptureISOPath -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing $CaptureISOPath : $($_.Exception.Message)" }
+        }
+        if ($RemoveDeployISO -and -not [string]::IsNullOrWhiteSpace($DeployISOPath) -and (Test-Path -LiteralPath $DeployISOPath)) {
+            WriteLog "CommonCleanup: Removing $DeployISOPath"
+            try { Remove-Item -LiteralPath $DeployISOPath -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing $DeployISOPath : $($_.Exception.Message)" }
+        }
+        if ($RemoveAppsISO -and -not [string]::IsNullOrWhiteSpace($AppsISOPath) -and (Test-Path -LiteralPath $AppsISOPath)) {
+            WriteLog "CommonCleanup: Removing $AppsISOPath"
+            try { Remove-Item -LiteralPath $AppsISOPath -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing $AppsISOPath : $($_.Exception.Message)" }
+        }
+
+        # Legacy / root-level WinPE ISOs (pattern-based)
+        if ($RemoveCaptureISO) {
+            Get-ChildItem -LiteralPath $RootPath -Filter 'WinPE_FFU_Capture*.iso' -ErrorAction SilentlyContinue | ForEach-Object {
+                try { WriteLog "CommonCleanup: Removing legacy capture ISO $($_.FullName)"; Remove-Item -LiteralPath $_.FullName -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing legacy capture ISO $($_.FullName) : $($_.Exception.Message)" }
+            }
+        }
+        if ($RemoveDeployISO) {
+            Get-ChildItem -LiteralPath $RootPath -Filter 'WinPE_FFU_Deploy*.iso' -ErrorAction SilentlyContinue | ForEach-Object {
+                try { WriteLog "CommonCleanup: Removing legacy deploy ISO $($_.FullName)"; Remove-Item -LiteralPath $_.FullName -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing legacy deploy ISO $($_.FullName) : $($_.Exception.Message)" }
+            }
+        }
+
+        if ($RemoveDrivers -and -not [string]::IsNullOrWhiteSpace($DriversPath) -and (Test-Path -LiteralPath $DriversPath -PathType Container)) {
+            WriteLog "CommonCleanup: Removing contents of $DriversPath (preserving Drivers.json and DriverMapping.json)"
+            try {
+                # Preserve drivers json files
+                $driverItems = Get-ChildItem -LiteralPath $DriversPath -Force -ErrorAction SilentlyContinue | Where-Object { @('Drivers.json', 'DriverMapping.json') -notcontains $_.Name }
+                if ($driverItems) {
+                    $driverItems | Remove-Item -Force -Recurse -ErrorAction SilentlyContinue
+                }
+            }
+            catch { WriteLog "CommonCleanup: Driver content cleanup issue: $($_.Exception.Message)" }
+        }
+
+        if ($RemoveFFU -and -not [string]::IsNullOrWhiteSpace($FFUCapturePath) -and (Test-Path -LiteralPath $FFUCapturePath -PathType Container)) {
+            WriteLog "CommonCleanup: Removing FFU files in $FFUCapturePath"
+            Get-ChildItem -LiteralPath $FFUCapturePath -Filter *.ffu -ErrorAction SilentlyContinue | ForEach-Object {
+                try { Remove-Item -LiteralPath $_.FullName -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing FFU $($_.FullName) : $($_.Exception.Message)" }
+            }
+        }
+
+        if ($RemoveApps -and -not [string]::IsNullOrWhiteSpace($AppsPath) -and (Test-Path -LiteralPath $AppsPath -PathType Container)) {
+            $win32 = Join-Path $AppsPath 'Win32'
+            $store = Join-Path $AppsPath 'MSStore'
+            if (Test-Path -LiteralPath $win32) {
+                WriteLog "CommonCleanup: Removing $win32"
+                try { Remove-Item -LiteralPath $win32 -Recurse -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing $win32 : $($_.Exception.Message)" }
+            }
+            if (Test-Path -LiteralPath $store) {
+                WriteLog "CommonCleanup: Removing $store"
+                try { Remove-Item -LiteralPath $store -Recurse -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing $store : $($_.Exception.Message)" }
+            }
+            $office = Join-Path $AppsPath 'Office'
+            if ((Test-Path -LiteralPath $office) -and $InstallOffice) {
+                WriteLog "CommonCleanup: Checking for Office artifacts in $office"
+                $officeSub = Join-Path $office 'Office'
+                if (Test-Path -LiteralPath $officeSub) {
+                    WriteLog "CommonCleanup: Removing $officeSub"
+                    try { Remove-Item -LiteralPath $officeSub -Recurse -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing $officeSub : $($_.Exception.Message)" }
+                }
+                $setupExe = Join-Path $office 'setup.exe'
+                if (Test-Path -LiteralPath $setupExe) {
+                    WriteLog "CommonCleanup: Removing $setupExe"
+                    try { Remove-Item -LiteralPath $setupExe -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing $setupExe : $($_.Exception.Message)" }
+                }
+            }
+        }
+
+        # Always remove LTSC update staging folder (out-of-band cleanup exception)
+        if (-not [string]::IsNullOrWhiteSpace($AppsPath) -and (Test-Path -LiteralPath $AppsPath -PathType Container)) {
+            $ltscUpdateFolder = Join-Path $AppsPath 'LTSCUpdate'
+            if (Test-Path -LiteralPath $ltscUpdateFolder) {
+                WriteLog "CommonCleanup: Removing LTSC update staging folder $ltscUpdateFolder"
+                try { Remove-Item -LiteralPath $ltscUpdateFolder -Recurse -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing $ltscUpdateFolder : $($_.Exception.Message)" }
+            }
+        }
+
+        if ($RemoveUpdates) {
+            if (-not [string]::IsNullOrWhiteSpace($AppsPath) -and (Test-Path -LiteralPath $AppsPath)) {
+                # Remove per-run app update payloads stored under Apps
+                $appUpdateDirs = @('Defender', 'Edge', 'MSRT', 'OneDrive')
+                foreach ($d in $appUpdateDirs) {
+                    $target = Join-Path $AppsPath $d
+                    if (Test-Path -LiteralPath $target) {
+                        WriteLog "CommonCleanup: Removing update folder $target"
+                        try { Remove-Item -LiteralPath $target -Recurse -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing $target : $($_.Exception.Message)" }
+                    }
+                }
+            }
+            if (-not [string]::IsNullOrWhiteSpace($KBPath) -and (Test-Path -LiteralPath $KBPath)) {
+                # Remove Windows/.NET CU downloads stored under KB
+                WriteLog "CommonCleanup: Removing downloaded updates in $KBPath"
+                try { Remove-Item -LiteralPath $KBPath -Recurse -Force -ErrorAction Stop } catch { WriteLog "CommonCleanup: Failed removing $KBPath : $($_.Exception.Message)" }
+            }
+        }
+
+        # Remove downloaded ESD files from the root path when requested
+        if ($RemoveDownloadedESD -and -not [string]::IsNullOrWhiteSpace($RootPath) -and (Test-Path -LiteralPath $RootPath -PathType Container)) {
+            WriteLog "CommonCleanup: Removing downloaded ESD files in $RootPath"
+            Get-ChildItem -LiteralPath $RootPath -Filter *.esd -File -ErrorAction SilentlyContinue | ForEach-Object {
+                try {
+                    WriteLog "CommonCleanup: Removing ESD $($_.FullName)"
+                    Remove-Item -LiteralPath $_.FullName -Force -ErrorAction Stop
+                }
+                catch {
+                    WriteLog "CommonCleanup: Failed removing ESD $($_.FullName) : $($_.Exception.Message)"
+                }
+            }
+        }
+
+        WriteLog "CommonCleanup: Completed."
+    }
+    catch {
+        WriteLog "CommonCleanup: Fatal cleanup error $($_.Exception.Message)"
+    }
+    finally {
+        $ProgressPreference = $originalProgressPreference
+    }
+}
+
+Export-ModuleMember -Function Invoke-FFUPostBuildCleanup

FFUDevelopment/FFU.Common/FFU.Common.Core.psm1

@@ -12,6 +12,10 @@ $script:CommonCoreLogFilePath = $null
 # Mutex for log file access
 $script:commonCoreLogMutexName = "Global\FFUCommonCoreLogMutex" # Unique name
 $script:commonCoreLogMutex = New-Object System.Threading.Mutex($false, $script:commonCoreLogMutexName)
+$script:BitsTransferPriority = 'Normal'
+if (-not [string]::IsNullOrWhiteSpace($env:FFU_BITS_PRIORITY)) {
+    $script:BitsTransferPriority = $env:FFU_BITS_PRIORITY
+}
 
 # Function to set the log file path for this module
 function Set-CommonCoreLogPath {
@@ -31,6 +35,23 @@ function Set-CommonCoreLogPath {
     }
 }
         
+function Set-BitsTransferPriority {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [ValidateSet('Foreground', 'High', 'Normal', 'Low')]
+        [string]$Priority
+    )
+    $script:BitsTransferPriority = $Priority
+    try {
+        Set-Item -Path Env:FFU_BITS_PRIORITY -Value $Priority -ErrorAction Stop
+    }
+    catch {
+        WriteLog "Failed to set FFU_BITS_PRIORITY environment variable: $($_.Exception.Message)"
+    }
+    WriteLog "BITS transfer priority set to $Priority."
+}
+        
 # Centralized WriteLog function
 function WriteLog {
     [CmdletBinding()]
@@ -136,6 +157,79 @@ function Invoke-Process {
     return $cmd
 }
 
+function Get-RunManifestPathForDownloadTarget {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$Destination
+    )
+
+    try {
+        $currentPath = Split-Path -Path $Destination -Parent
+        if ([string]::IsNullOrWhiteSpace($currentPath)) { return $null }
+
+        while ($currentPath) {
+            $manifestPath = Join-Path -Path $currentPath -ChildPath '.session\currentRun.json'
+            if (Test-Path -LiteralPath $manifestPath -PathType Leaf) {
+                return $manifestPath
+            }
+
+            $parentPath = Split-Path -Path $currentPath -Parent
+            if ([string]::IsNullOrWhiteSpace($parentPath) -or $parentPath -eq $currentPath) {
+                break
+            }
+            $currentPath = $parentPath
+        }
+    }
+    catch {
+        WriteLog "Get-RunManifestPathForDownloadTarget failed for '$Destination': $($_.Exception.Message)"
+    }
+
+    return $null
+}
+
+function Register-CurrentRunDownloadTarget {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$Destination
+    )
+
+    if ([string]::IsNullOrWhiteSpace($Destination)) { return }
+
+    $manifestPath = Get-RunManifestPathForDownloadTarget -Destination $Destination
+    if ([string]::IsNullOrWhiteSpace($manifestPath)) { return }
+
+    $mutexName = 'Global\FFUCurrentRunDownloadTargetsMutex'
+    $mutex = New-Object System.Threading.Mutex($false, $mutexName)
+
+    try {
+        $null = $mutex.WaitOne()
+
+        $manifest = Get-Content -LiteralPath $manifestPath -Raw -ErrorAction Stop | ConvertFrom-Json -ErrorAction Stop
+        if ($null -eq $manifest) { return }
+
+        if ($null -eq $manifest.PSObject.Properties['DownloadTargets']) {
+            Add-Member -InputObject $manifest -MemberType NoteProperty -Name DownloadTargets -Value @()
+        }
+
+        $downloadTargets = @($manifest.DownloadTargets)
+        if ($Destination -notin $downloadTargets) {
+            $downloadTargets += $Destination
+            $manifest.DownloadTargets = $downloadTargets
+            $manifest | ConvertTo-Json -Depth 8 | Set-Content -LiteralPath $manifestPath -Encoding UTF8
+            WriteLog "Registered current-run download target: $Destination"
+        }
+    }
+    catch {
+        WriteLog "Register-CurrentRunDownloadTarget failed for '$Destination': $($_.Exception.Message)"
+    }
+    finally {
+        try { $mutex.ReleaseMutex() | Out-Null } catch {}
+        $mutex.Dispose()
+    }
+}
+
 # Function to download a file using BITS with retry and error handling
 function Start-BitsTransferWithRetry {
     param (
@@ -143,20 +237,40 @@ function Start-BitsTransferWithRetry {
         [string]$Source,
         [Parameter(Mandatory = $true)]
         [string]$Destination,
-        [int]$Retries = 3
+        [int]$Retries = 3,
+        [ValidateSet('Foreground','High','Normal','Low')]
+        [string]$Priority
     )
 
+    if ([string]::IsNullOrWhiteSpace($Priority)) {
+        if (-not [string]::IsNullOrWhiteSpace($env:FFU_BITS_PRIORITY)) {
+            $Priority = $env:FFU_BITS_PRIORITY
+        }
+        elseif (-not [string]::IsNullOrWhiteSpace($script:BitsTransferPriority)) {
+            $Priority = $script:BitsTransferPriority
+        }
+        else {
+            $Priority = 'Normal'
+        }
+    }
+
+    # Register destination so cancel cleanup can remove this run's downloaded files
+    # even when file timestamps are inherited from the source.
+    Register-CurrentRunDownloadTarget -Destination $Destination
+
     $attempt = 0
     $lastError = $null
+    $notLoggedOnHResult = [int]0x800704dd
+    $fallbackTriggered = $false
 
-    while ($attempt -lt $Retries) {
+    while ($attempt -lt $Retries -and -not $fallbackTriggered) {
         $OriginalVerbosePreference = $VerbosePreference
         $OriginalProgressPreference = $ProgressPreference
         try {
             $VerbosePreference = 'SilentlyContinue'
             $ProgressPreference = 'SilentlyContinue'
 
-            Start-BitsTransfer -Source $Source -Destination $Destination -ErrorAction Stop
+            Start-BitsTransfer -Source $Source -Destination $Destination -Priority $Priority -ErrorAction Stop
             
             $ProgressPreference = $OriginalProgressPreference
             $VerbosePreference = $OriginalVerbosePreference
@@ -166,7 +280,24 @@ function Start-BitsTransferWithRetry {
         catch {
             $lastError = $_
             $attempt++
-            WriteLog "Attempt $attempt of $Retries failed to download $Source. Error: $($lastError.Exception.Message)." 
+            $errorMessage = $lastError.Exception.Message
+            WriteLog "Attempt $attempt of $Retries failed to download $Source. Error: $errorMessage."
+            $hResult = $null
+            if ($null -ne $lastError.Exception) {
+                $hResult = $lastError.Exception.HResult
+            }
+            $needsHttpFallback = $false
+            if ($hResult -eq $notLoggedOnHResult) {
+                $needsHttpFallback = $true
+            }
+            elseif ($errorMessage -match '0x800704DD' -or $errorMessage -match 'not.*logged on to the network') {
+                $needsHttpFallback = $true
+            }
+            if ($needsHttpFallback) {
+                WriteLog "BITS cannot download $Source because the current session is not logged on to the network. Falling back to Invoke-WebRequest."
+                $fallbackTriggered = $true
+                break
+            }
             Start-Sleep -Seconds (1 * $attempt)
         }
         finally {
@@ -179,6 +310,41 @@ function Start-BitsTransferWithRetry {
         }
     }
 
+    if ($fallbackTriggered) {
+        $remainingAttempts = $Retries - $attempt
+        if ($remainingAttempts -lt 1) {
+            $remainingAttempts = 1
+        }
+        $httpAttempt = 0
+        while ($httpAttempt -lt $remainingAttempts) {
+            $httpAttempt++
+            $OriginalVerbosePreference = $VerbosePreference
+            $OriginalProgressPreference = $ProgressPreference
+            try {
+                $VerbosePreference = 'SilentlyContinue'
+                $ProgressPreference = 'SilentlyContinue'
+                Invoke-WebRequest -Uri $Source -OutFile $Destination -ErrorAction Stop
+                $ProgressPreference = $OriginalProgressPreference
+                $VerbosePreference = $OriginalVerbosePreference
+                WriteLog "Successfully transferred $Source to $Destination via HTTP fallback."
+                return
+            }
+            catch {
+                $lastError = $_
+                WriteLog "HTTP fallback attempt $httpAttempt of $remainingAttempts failed to download $Source. Error: $($lastError.Exception.Message)."
+                Start-Sleep -Seconds (1 * $httpAttempt)
+            }
+            finally {
+                if (Get-Variable -Name 'OriginalProgressPreference' -ErrorAction SilentlyContinue) {
+                    $ProgressPreference = $OriginalProgressPreference
+                }
+                if (Get-Variable -Name 'OriginalVerbosePreference' -ErrorAction SilentlyContinue) {
+                    $VerbosePreference = $OriginalVerbosePreference
+                }
+            }
+        }
+    }
+
     WriteLog "Failed to download $Source after $Retries attempts. Last Error: $($lastError.Exception.Message)"
     throw $lastError
 }
@@ -194,4 +360,22 @@ function Set-Progress {
     WriteLog "[PROGRESS] $Percentage | $Message"
 }
     
+function ConvertTo-SafeName {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$Name
+    )
+    # Replace invalid Windows filename characters (<>:"/\|?* and control chars) with a dash
+    $sanitized = $Name -replace '[<>:\"/\\|?*\x00-\x1F]', '-'
+    # Collapse multiple consecutive dashes
+    $sanitized = $sanitized -replace '-{2,}', '-'
+    # Trim leading/trailing spaces, periods, and dashes
+    $sanitized = $sanitized.Trim(' ', '.', '-')
+    if ([string]::IsNullOrWhiteSpace($sanitized)) {
+        $sanitized = 'Unnamed'
+    }
+    return $sanitized
+}
+
 Export-ModuleMember -Function *

FFUDevelopment/FFU.Common/FFU.Common.Drivers.Dell.psm1

@@ -0,0 +1,300 @@
+<#
+.SYNOPSIS
+    Common Dell driver helpers (catalog index, model listing, latest package selection).
+#>
+
+function Convert-DellVendorVersion {
+    param([Parameter(Mandatory=$true)][string]$VendorVersion)
+    $segments = $VendorVersion.Split('.') | ForEach-Object {
+        if ($_ -match '^\d+$') { [int]$_ } else { 0 }
+    }
+    return ,$segments
+}
+
+function Compare-DellVendorVersion {
+    param(
+        [int[]]$Left,
+        [int[]]$Right
+    )
+    $len = [Math]::Max($Left.Length,$Right.Length)
+    for ($i=0; $i -lt $len; $i++) {
+        $l = if ($i -lt $Left.Length) { $Left[$i] } else { 0 }
+        $r = if ($i -lt $Right.Length) { $Right[$i] } else { 0 }
+        if ($l -gt $r) { return 1 }
+        if ($l -lt $r) { return -1 }
+    }
+    return 0
+}
+
+function Get-DellCatalogIndex {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory=$true)][string]$DriversFolder
+    )
+
+    $dellFolder = Join-Path $DriversFolder 'Dell'
+    if (-not (Test-Path $dellFolder)) { New-Item -Path $dellFolder -ItemType Directory -Force | Out-Null }
+    $cabPath = Join-Path $dellFolder 'CatalogIndexPC.cab'
+    $xmlPath = Join-Path $dellFolder 'CatalogIndexPC.xml'
+    $url = 'https://downloads.dell.com/catalog/CatalogIndexPC.cab'
+
+    $need = $true
+    if (Test-Path $xmlPath) {
+        $ageDays = ((Get-Date) - (Get-Item $xmlPath).CreationTime).TotalDays
+        if ($ageDays -lt 7) { $need = $false }
+    }
+
+    if ($need) {
+        if (Test-Path $cabPath) { Remove-Item $cabPath -Force -ErrorAction SilentlyContinue }
+        if (Test-Path $xmlPath) { Remove-Item $xmlPath -Force -ErrorAction SilentlyContinue }
+        Start-BitsTransferWithRetry -Source $url -Destination $cabPath
+        Invoke-Process -FilePath Expand.exe -ArgumentList """$cabPath"" ""$xmlPath""" | Out-Null
+        Remove-Item $cabPath -Force -ErrorAction SilentlyContinue
+    }
+
+    if (-not (Test-Path $xmlPath)) { throw "Dell CatalogIndexPC XML missing: $xmlPath" }
+    return $xmlPath
+}
+
+function Get-DellClientModels {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory=$true)][string]$CatalogIndexXmlPath
+    )
+
+    $settings = New-Object System.Xml.XmlReaderSettings
+    $settings.IgnoreWhitespace = $true
+    $settings.IgnoreComments = $true
+    $reader = [System.Xml.XmlReader]::Create($CatalogIndexXmlPath,$settings)
+
+    $models = [System.Collections.Generic.List[pscustomobject]]::new()
+    try {
+        while ($reader.Read()) {
+            if ($reader.NodeType -eq [System.Xml.XmlNodeType]::Element -and $reader.Name -eq 'GroupManifest') {
+                # Read subtree to pick out brand/model/systemID + path
+                $sub = $reader.ReadSubtree()
+                $doc = New-Object System.Xml.XmlDocument
+                $doc.Load($sub)
+                $sub.Dispose()
+
+                # Use local-name() to ignore namespaces
+                $brandNode = $doc.SelectSingleNode("//*[local-name()='SupportedSystems']/*[local-name()='Brand']")
+                if (-not $brandNode) { continue }
+                $brandDisplay = ($brandNode.SelectSingleNode("*[local-name()='Display']")?.InnerText).Trim()
+                $modelNode = $brandNode.SelectSingleNode("*[local-name()='Model']")
+                if (-not $modelNode) { continue }
+                $modelNumber = ($modelNode.SelectSingleNode("*[local-name()='Display']")?.InnerText).Trim()
+                $systemId = $modelNode.GetAttribute('systemID')
+                $manifestInfo = $doc.SelectSingleNode("//*[local-name()='ManifestInformation']")
+                if (-not $manifestInfo) { continue }
+                $pathAttr = $manifestInfo.GetAttribute('path')
+                if (-not $pathAttr) { continue }
+                $cabUrl = 'https://downloads.dell.com/' + $pathAttr
+                # Normalize model display using GroupManifest Display CDATA if available (strip 'PDK Catalog for')
+                $gmDisplayNode = $doc.SelectSingleNode("/*[local-name()='GroupManifest']/*[local-name()='Display']")
+                $modelFull = $null
+                if ($gmDisplayNode -and $gmDisplayNode.InnerText) {
+                    $rawDisplay = $gmDisplayNode.InnerText.Trim()
+                    $modelFull = ($rawDisplay -replace '^\s*PDK Catalog for\s+','').Trim()
+                }
+                if ([string]::IsNullOrWhiteSpace($modelFull)) {
+                    # Fallback: assemble from brand/model nodes (legacy heuristic)
+                    $prefixedModelNumber = $modelNumber
+                    if ($modelNumber -and $brandDisplay) {
+                        if ($modelNumber.StartsWith($brandDisplay,[System.StringComparison]::OrdinalIgnoreCase)) {
+                            $prefixedModelNumber = $modelNumber
+                        }
+                        else {
+                            $prefixedModelNumber = "$brandDisplay $modelNumber"
+                        }
+                    }
+                    elseif ($brandDisplay -and -not $modelNumber) {
+                        $prefixedModelNumber = $brandDisplay
+                    }
+                    $modelFull = $prefixedModelNumber
+                }
+                $modelDisplay = "$modelFull ($systemId)"
+                $models.Add([pscustomobject]@{
+                    Brand           = $brandDisplay
+                    ModelNumber     = $modelNumber
+                    SystemId        = $systemId
+                    CabRelativePath = $pathAttr
+                    CabUrl          = $cabUrl
+                    ModelDisplay    = $modelDisplay
+                })
+            }
+        }
+    }
+    finally {
+        $reader.Dispose()
+    }
+    return $models
+}
+
+function Get-DellLatestDriverPackages {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory=$true)][string]$ModelXmlPath,
+        [Parameter(Mandatory=$true)][string]$WindowsArch,
+        [Parameter(Mandatory=$true)][int]$WindowsRelease
+    )
+
+    if (-not (Test-Path $ModelXmlPath)) { throw "Model XML not found: $ModelXmlPath" }
+
+    $xml = [xml](Get-Content -Path $ModelXmlPath -Raw)
+
+    # Collect all SoftwareComponent nodes
+    $components = $xml.SelectNodes("//*[local-name()='SoftwareComponent']")
+    if (-not $components) { return @() }
+
+    $rawPackages = [System.Collections.Generic.List[pscustomobject]]::new()
+
+    foreach ($comp in $components) {
+        $ctype = $comp.SelectSingleNode("*[local-name()='ComponentType']")
+        if (-not $ctype) { continue }
+        if ($ctype.GetAttribute('value') -ne 'DRVR') { continue }
+
+        # OS filtering (arch only – release filtering intentionally minimal for now)
+        $osNodes = @($comp.SelectNodes("*[local-name()='SupportedOperatingSystems']/*[local-name()='OperatingSystem']"))
+        if (-not $osNodes) { continue }
+        $validOS = $osNodes | Where-Object { $_.GetAttribute('osArch') -eq $WindowsArch } | Select-Object -First 1
+        if (-not $validOS) { continue }
+
+        $path = $comp.GetAttribute('path')
+        if (-not $path) { continue }
+
+        $downloadUrl    = "https://downloads.dell.com/$path"
+        $fileName       = [IO.Path]::GetFileName($path)
+        $vendorVersion  = $comp.GetAttribute('vendorVersion')
+        $versionArr     = if ($vendorVersion) { Convert-DellVendorVersion $vendorVersion } else { @(0) }
+        $dateTimeAttr   = $comp.GetAttribute('dateTime')
+        $dt             = Get-Date
+        if ($dateTimeAttr) {
+            try { $dt = [DateTime]::Parse($dateTimeAttr) } catch { }
+        }
+
+        $categoryNode = $comp.SelectSingleNode("*[local-name()='Category']/*[local-name()='Display']")
+        $category     = if ($categoryNode) { $categoryNode.InnerText.Trim() } else { 'Uncategorized' }
+
+        # Collect componentIDs (SupportedDevices + SupportedDCHDevices)
+        $compIds = [System.Collections.Generic.List[string]]::new()
+        $devNodes = @($comp.SelectNodes(".//*[local-name()='Device']"))
+        foreach ($dn in $devNodes) {
+            $id = $dn.GetAttribute('componentID')
+            if ($id) { [void]$compIds.Add($id) }
+        }
+        if ($compIds.Count -eq 0) { continue }
+
+        # Build a deterministic sortable key: zero-pad each numeric segment to 6 digits
+        $versionSortable = ($versionArr | ForEach-Object { $_.ToString('D6') }) -join '-'
+
+        # Capture a human‑readable driver name (preserve spaces like HP/Lenovo; remove only illegal path chars and extra whitespace)
+        $displayNode = $comp.SelectSingleNode("*[local-name()='Name']/*[local-name()='Display']")
+        $nameRaw     = if ($displayNode) { $displayNode.InnerText.Trim() } else { $fileName }
+        # Remove characters not suitable for display (and disallowed in file names) but keep spaces
+        $nameDisplay = $nameRaw -replace '[\\\/:\*\?\"\<\>\|]', ' ' -replace '[,]', '-' 
+        # Collapse multiple spaces to single
+        $nameDisplay = ($nameDisplay -replace '\s+', ' ').Trim()
+
+        $rawPackages.Add([pscustomobject]@{
+            Path            = $path
+            DownloadUrl     = $downloadUrl
+            FileName        = $fileName
+            Name            = $nameDisplay
+            Category        = $category
+            VendorVersion   = $vendorVersion
+            VersionArray    = $versionArr
+            VersionSortable = $versionSortable
+            DateTime        = $dt
+            ComponentIds    = $compIds
+        })
+    }
+
+    if ($rawPackages.Count -eq 0) { return @() }
+
+    # Sort newest first by VersionSortable (lexicographic works due to zero padding) then DateTime
+    $sorted = $rawPackages | Sort-Object -Property @{ Expression = { $_.VersionSortable }; Descending = $true }, @{ Expression = { $_.DateTime }; Descending = $true }
+
+    $chosen      = [System.Collections.Generic.List[pscustomobject]]::new()
+    $assignedIds = [System.Collections.Generic.HashSet[string]]::new()
+
+    foreach ($pkg in $sorted) {
+        $hasOverlap = $false
+        foreach ($cid in $pkg.ComponentIds) {
+            if ($assignedIds.Contains($cid)) { $hasOverlap = $true; break }
+        }
+        if ($hasOverlap) {
+            WriteLog "Get-DellLatestDriverPackages: Skipping superseded package $($pkg.FileName) (shared componentID with newer package)."
+            continue
+        }
+
+        foreach ($cid in $pkg.ComponentIds) { [void]$assignedIds.Add($cid) }
+
+        $chosen.Add([pscustomobject]@{
+            Path           = $pkg.Path
+            DownloadUrl    = $pkg.DownloadUrl
+            DriverFileName = $pkg.FileName
+            Name           = $pkg.Name
+            Category       = $pkg.Category
+            VendorVersion  = $pkg.VendorVersion
+            DateTime       = $pkg.DateTime
+            ComponentIds   = $pkg.ComponentIds
+        })
+    }
+
+    if ($chosen.Count -eq 0) {
+        WriteLog "Get-DellLatestDriverPackages: No qualifying driver packages after supersedence."
+        return @()
+    }
+
+    WriteLog ("Get-DellLatestDriverPackages: Selected {0} package(s) after supersedence." -f $chosen.Count)
+    return $chosen
+}
+
+# Resolve a Dell per‑model CabUrl when missing by inspecting CatalogIndexPC
+function Resolve-DellCabUrlFromModel {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)][string]$DriversFolder,
+        [Parameter()][string]$ModelDisplay,
+        [Parameter()][string]$SystemId
+    )
+
+    if ([string]::IsNullOrWhiteSpace($SystemId) -and -not [string]::IsNullOrWhiteSpace($ModelDisplay)) {
+        # Try to parse the trailing (XXXX) token (SystemId)
+        if ($ModelDisplay -match '\(([0-9A-Fa-f]{4})\)\s*$') {
+            $SystemId = $matches[1].ToUpperInvariant()
+        }
+    }
+
+    if ([string]::IsNullOrWhiteSpace($SystemId)) {
+        WriteLog "Resolve-DellCabUrlFromModel: No SystemId could be determined from '$ModelDisplay'."
+        return $null
+    }
+
+    try {
+        $indexXml = Get-DellCatalogIndex -DriversFolder $DriversFolder
+        # Reuse existing model parsing to avoid duplicating streaming logic
+        $allModels = Get-DellClientModels -CatalogIndexXmlPath $indexXml
+        $match = $allModels | Where-Object { $_.SystemId -eq $SystemId } | Select-Object -First 1
+        if ($null -eq $match) {
+            WriteLog "Resolve-DellCabUrlFromModel: SystemId '$SystemId' not found in CatalogIndexPC.xml."
+            return $null
+        }
+        WriteLog "Resolve-DellCabUrlFromModel: Resolved CabUrl for '$($match.ModelDisplay)' -> $($match.CabUrl)"
+        return [pscustomobject]@{
+            Brand           = $match.Brand
+            ModelNumber     = $match.ModelNumber
+            SystemId        = $match.SystemId
+            CabRelativePath = $match.CabRelativePath
+            CabUrl          = $match.CabUrl
+            ModelDisplay    = $match.ModelDisplay
+        }
+    }
+    catch {
+        WriteLog "Resolve-DellCabUrlFromModel: Failure resolving CabUrl for '$ModelDisplay' / SystemId '$SystemId' : $($_.Exception.Message)"
+        return $null
+    }
+}
+
+Export-ModuleMember -Function Convert-DellVendorVersion,Compare-DellVendorVersion,Get-DellCatalogIndex,Get-DellClientModels,Get-DellLatestDriverPackages,Resolve-DellCabUrlFromModel

FFUDevelopment/FFU.Common/FFU.Common.Drivers.Microsoft.psm1

@@ -0,0 +1,591 @@
+<#
+.SYNOPSIS
+    Common Microsoft/Surface driver helpers (cache index, SKU mapping).
+.DESCRIPTION
+    This module contains Microsoft/Surface-specific functions used by the UI and scripts
+    to map Surface driver packs to System SKU values using:
+    - Source A: Surface System SKU reference (Learn)
+    - Source B: Support page model list
+    - Source C: Download Center details (window.__DLCDetails__)
+#>
+
+# --------------------------------------------------------------------------
+# SECTION: Microsoft Surface Driver Index Cache (Sources A/B/C)
+# --------------------------------------------------------------------------
+
+function Get-SurfaceDriverIndexCachePath {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$DriversFolder
+    )
+
+    # Store the cache under Drivers\Microsoft so it travels with the driver content
+    $microsoftDriversFolder = Join-Path -Path $DriversFolder -ChildPath 'Microsoft'
+    if (-not (Test-Path -Path $microsoftDriversFolder -PathType Container)) {
+        New-Item -Path $microsoftDriversFolder -ItemType Directory -Force | Out-Null
+    }
+
+    return (Join-Path -Path $microsoftDriversFolder -ChildPath 'SurfaceDriverIndex.json')
+}
+
+function Import-SurfaceDriverIndexCache {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$DriversFolder
+    )
+
+    $cachePath = Get-SurfaceDriverIndexCachePath -DriversFolder $DriversFolder
+
+    # Surface cache TTL (7 days): treat stale caches as missing so we re-download Sources A/B/C as needed.
+    $cacheTtlDays = 7
+    if (-not (Test-Path -Path $cachePath -PathType Leaf)) {
+        return [pscustomobject]@{
+            ModelIndex            = @()
+            SkuIndex              = @()
+            DownloadCenterDetails = @()
+        }
+    }
+
+    try {
+        $cacheAgeDays = ((Get-Date) - (Get-Item -Path $cachePath -ErrorAction Stop).LastWriteTime).TotalDays
+        if ($cacheAgeDays -ge $cacheTtlDays) {
+            WriteLog "Surface cache: Cache file '$cachePath' is older than $cacheTtlDays days ($([math]::Round($cacheAgeDays, 1)) days). Refreshing."
+            return [pscustomobject]@{
+                ModelIndex            = @()
+                SkuIndex              = @()
+                DownloadCenterDetails = @()
+            }
+        }
+
+        WriteLog "Surface cache: Loading cached SurfaceDriverIndex.json from '$cachePath' (age: $([math]::Round($cacheAgeDays, 1)) days)."
+    }
+    catch {
+        WriteLog "Surface cache: Failed to read cache timestamp for '$cachePath'. Refreshing. Error: $($_.Exception.Message)"
+        return [pscustomobject]@{
+            ModelIndex            = @()
+            SkuIndex              = @()
+            DownloadCenterDetails = @()
+        }
+    }
+
+    try {
+        $cache = Get-Content -Path $cachePath -Raw | ConvertFrom-Json -ErrorAction Stop
+    }
+    catch {
+        WriteLog "Warning: Could not read Surface driver cache '$cachePath'. Creating a new cache. Error: $($_.Exception.Message)"
+        return [pscustomobject]@{
+            ModelIndex            = @()
+            SkuIndex              = @()
+            DownloadCenterDetails = @()
+        }
+    }
+
+    if ($null -eq $cache) {
+        return [pscustomobject]@{
+            ModelIndex            = @()
+            SkuIndex              = @()
+            DownloadCenterDetails = @()
+        }
+    }
+
+    # Ensure expected properties exist (backward compatible with earlier cache shapes)
+    if (-not $cache.PSObject.Properties['ModelIndex']) {
+        $cache | Add-Member -NotePropertyName ModelIndex -NotePropertyValue @()
+    }
+    if (-not $cache.PSObject.Properties['SkuIndex']) {
+        $cache | Add-Member -NotePropertyName SkuIndex -NotePropertyValue @()
+    }
+    if (-not $cache.PSObject.Properties['DownloadCenterDetails']) {
+        $cache | Add-Member -NotePropertyName DownloadCenterDetails -NotePropertyValue @()
+    }
+
+    return $cache
+}
+
+function Save-SurfaceDriverIndexCache {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject]$Cache,
+        [Parameter(Mandatory = $true)]
+        [string]$DriversFolder
+    )
+
+    $cachePath = Get-SurfaceDriverIndexCachePath -DriversFolder $DriversFolder
+    $Cache | ConvertTo-Json -Depth 10 | Set-Content -Path $cachePath -Encoding UTF8
+}
+
+function ConvertTo-SurfaceComparableName {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$Text
+    )
+
+    # Normalize Surface marketing strings into a comparable family key.
+    # This intentionally strips consumer/commercial/processor qualifiers so we can join Sources A/B/C.
+    $value = [System.Net.WebUtility]::HtmlDecode($Text)
+    if ([string]::IsNullOrWhiteSpace($value)) {
+        return $null
+    }
+
+    $value = $value.Trim()
+    $value = $value -replace '\(', ' '
+    $value = $value -replace '\)', ' '
+    $value = $value -replace ',', ' '
+
+    # Normalize punctuation that frequently differs between Support/Learn pages
+    # (e.g. Wi‑Fi unicode hyphen, AT&T, Y!mobile)
+    $value = $value -replace '[-\u2010\u2011\u2012\u2013\u2014\u2212]', ' '
+    $value = $value -replace '&', ' '
+    $value = $value -replace '!', ' '
+    $value = $value -replace '™', ' '
+
+    $value = $value -replace '(?i)\bMicrosoft\b', ''
+    $value = $value -replace '(?i)\bfor\s+Business\b', ''
+    $value = $value -replace '(?i)\bConsumer\b', ''
+    $value = $value -replace '(?i)\bCommercial\b', ''
+
+    # Strip processor/connection qualifiers that cause mismatches between WMI, Learn, and Support naming.
+    $value = $value -replace '(?i)\bwith\s+Intel\b', ''
+    $value = $value -replace '(?i)\bIntel\s+processor\b', ''
+    $value = $value -replace '(?i)\bIntel\b', ''
+    $value = $value -replace '(?i)\bSnapdragon\s+processor\b', ''
+    $value = $value -replace '(?i)\bSnapdragon\b', ''
+    $value = $value -replace '(?i)\bwith\s+5G\b', ''
+    $value = $value -replace '(?i)\bLTE\b', ''
+    $value = $value -replace '(?i)\b4G\b', ''
+    $value = $value -replace '(?i)\bprocessor\b', ''
+
+    # Cleanup: remove orphaned "with" left behind by earlier removals (e.g., "Surface Pro 9 with Intel Processor")
+    $value = $value -replace '(?i)\bwith\b', ''
+    $value = $value -replace '\s+', ' '
+
+    return $value.Trim().ToUpperInvariant()
+}
+
+function Get-SurfaceSystemSkuReferenceIndex {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$DriversFolder
+    )
+
+    # Source A: Learn page with authoritative Device / System Model / System SKU table
+    $cache = Import-SurfaceDriverIndexCache -DriversFolder $DriversFolder
+    if ($cache.SkuIndex -and $cache.SkuIndex.Count -gt 0) {
+        return @($cache.SkuIndex)
+    }
+
+    $url = 'https://learn.microsoft.com/en-us/surface/surface-system-sku-reference'
+    WriteLog "Surface cache: Downloading System SKU reference table from $url"
+
+    $headers = @{ 'User-Agent' = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)' }
+    $webContent = Invoke-WebRequest -Uri $url -UseBasicParsing -Headers $headers
+    $html = $webContent.Content
+
+    $skuRows = [System.Collections.Generic.List[pscustomobject]]::new()
+
+    $rowMatches = [regex]::Matches($html, '<tr[^>]*>(.*?)</tr>', [System.Text.RegularExpressions.RegexOptions]::Singleline)
+    foreach ($rowMatch in $rowMatches) {
+        $rowContent = $rowMatch.Groups[1].Value
+        $cellMatches = [regex]::Matches($rowContent, '<td[^>]*>\s*(?:<p[^>]*>)?(.*?)(?:</p>)?\s*</td>', [System.Text.RegularExpressions.RegexOptions]::Singleline)
+        if ($cellMatches.Count -lt 3) { continue }
+
+        $device = ([System.Net.WebUtility]::HtmlDecode(($cellMatches[0].Groups[1].Value).Trim()))
+        $systemModel = ([System.Net.WebUtility]::HtmlDecode(($cellMatches[1].Groups[1].Value).Trim()))
+        $systemSkuRaw = ([System.Net.WebUtility]::HtmlDecode(($cellMatches[2].Groups[1].Value).Trim()))
+
+        if ([string]::IsNullOrWhiteSpace($device) -or [string]::IsNullOrWhiteSpace($systemSkuRaw)) { continue }
+
+        $skuList = @($systemSkuRaw)
+
+        foreach ($sku in $skuList) {
+            if ([string]::IsNullOrWhiteSpace($sku)) { continue }
+            $skuRows.Add([pscustomobject]@{
+                    Device      = $device
+                    SystemModel = $systemModel
+                    SystemSku   = $sku.Trim().ToUpperInvariant()
+                })
+        }
+    }
+
+    $cache.SkuIndex = @($skuRows)
+    Save-SurfaceDriverIndexCache -Cache $cache -DriversFolder $DriversFolder
+    WriteLog "Surface cache: Stored $($skuRows.Count) SKU entries."
+
+    return @($skuRows)
+}
+
+function Get-SurfaceDownloadCenterDetails {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$DriversFolder,
+        [Parameter(Mandatory = $true)]
+        [string]$ModelLink,
+        [Parameter()]
+        [string]$ModelName = $null
+    )
+
+    # Source C: Download Center details page (window.__DLCDetails__) containing file names + direct URLs
+    $cache = Import-SurfaceDriverIndexCache -DriversFolder $DriversFolder
+    $existing = @($cache.DownloadCenterDetails | Where-Object { $_.Link -eq $ModelLink } | Select-Object -First 1)
+    if ($existing.Count -gt 0 -and $existing[0].Files -and $existing[0].Files.Count -gt 0) {
+        # Backfill Model into cache when available
+        if (-not [string]::IsNullOrWhiteSpace($ModelName)) {
+            if (-not $existing[0].PSObject.Properties['Model'] -or [string]::IsNullOrWhiteSpace($existing[0].Model)) {
+                try {
+                    $existing[0] | Add-Member -NotePropertyName Model -NotePropertyValue $ModelName -Force
+
+                    $newDetails = [System.Collections.Generic.List[pscustomobject]]::new()
+                    foreach ($item in @($cache.DownloadCenterDetails)) {
+                        if ($null -ne $item -and $item.PSObject.Properties['Link'] -and $item.Link -ne $ModelLink) {
+                            $newDetails.Add($item)
+                        }
+                    }
+                    $newDetails.Add($existing[0])
+                    $cache.DownloadCenterDetails = @($newDetails)
+                    Save-SurfaceDriverIndexCache -Cache $cache -DriversFolder $DriversFolder
+                }
+                catch {
+                    WriteLog "Surface cache: Failed to backfill Model for DownloadCenterDetails entry '$ModelLink'. Error: $($_.Exception.Message)"
+                }
+            }
+        }
+
+        return @($existing[0].Files)
+    }
+
+    WriteLog "Surface cache: Downloading Download Center details from $ModelLink"
+    $headers = @{ 'User-Agent' = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)' }
+    $downloadPageContent = Invoke-WebRequest -Uri $ModelLink -UseBasicParsing -Headers $headers
+
+    $scriptPattern = '<script>window.__DLCDetails__={(.*?)}<\/script>'
+    $scriptMatch = [regex]::Match($downloadPageContent.Content, $scriptPattern)
+    if (-not $scriptMatch.Success) {
+        WriteLog "Surface cache: Could not find window.__DLCDetails__ on $ModelLink"
+        return @()
+    }
+
+    $scriptContent = $scriptMatch.Groups[1].Value
+    $downloadFilePattern = '"name":"([^"]+\.(?:msi|zip))",[^}]*?"url":"(.*?)"'
+    $downloadFileMatches = [regex]::Matches($scriptContent, $downloadFilePattern, [System.Text.RegularExpressions.RegexOptions]::IgnoreCase)
+
+    $files = [System.Collections.Generic.List[pscustomobject]]::new()
+    foreach ($downloadFile in $downloadFileMatches) {
+        $currentFileName = $downloadFile.Groups[1].Value
+        $fileUrl = $downloadFile.Groups[2].Value
+        if ([string]::IsNullOrWhiteSpace($currentFileName) -or [string]::IsNullOrWhiteSpace($fileUrl)) { continue }
+
+        $files.Add([pscustomobject]@{
+                Name = $currentFileName
+                Url  = $fileUrl
+            })
+    }
+
+    # Persist into cache
+    if ($files.Count -gt 0) {
+        $detailsEntry = [pscustomobject][ordered]@{
+            Model = $ModelName
+            Link  = $ModelLink
+            Files = @($files)
+        }
+
+        $newDetails = [System.Collections.Generic.List[pscustomobject]]::new()
+        foreach ($item in @($cache.DownloadCenterDetails)) {
+            if ($null -ne $item -and $item.PSObject.Properties['Link'] -and $item.Link -ne $ModelLink) {
+                $newDetails.Add($item)
+            }
+        }
+        $newDetails.Add($detailsEntry)
+        $cache.DownloadCenterDetails = @($newDetails)
+        Save-SurfaceDriverIndexCache -Cache $cache -DriversFolder $DriversFolder
+    }
+
+    return @($files)
+}
+
+function Get-SurfaceSystemSkuListForMicrosoftDriver {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$DriversFolder,
+        [Parameter(Mandatory = $true)]
+        [string]$ModelName,
+        [Parameter(Mandatory = $true)]
+        [string]$ModelLink
+    )
+
+    $skuIndex = Get-SurfaceSystemSkuReferenceIndex -DriversFolder $DriversFolder
+    if ($null -eq $skuIndex -or $skuIndex.Count -eq 0) {
+        return @()
+    }
+
+    $files = Get-SurfaceDownloadCenterDetails -DriversFolder $DriversFolder -ModelLink $ModelLink -ModelName $ModelName
+    $fileNames = @($files | ForEach-Object { $_.Name })
+
+    # Infer architecture hints from the MSI naming convention (best-effort)
+    $archHint = $null
+    if ($fileNames -match '(?i)_ARM_') {
+        $archHint = 'ARM64'
+    }
+    elseif ($fileNames -match '(?i)withIntel|_Intel_|Intel') {
+        $archHint = 'x64'
+    }
+    elseif ($ModelName -match '(?i)\bSQ3\b|\bSnapdragon\b') {
+        $archHint = 'ARM64'
+    }
+    elseif ($ModelName -match '(?i)with Intel') {
+        $archHint = 'x64'
+    }
+
+    # Surface Pro (generic) is ambiguous in the SKU table because Surface Pro (5th Gen) and
+    # Surface Pro with LTE Advanced (5th Gen) both reuse SystemModel="Surface Pro".
+    # The "Surface Pro" driver pack does not have a unique SystemSKU value on the Learn page.
+    if ($ModelName.Trim() -match '(?i)^Surface\s+Pro$') {
+        return @()
+    }
+
+    # Build multiple candidate keys for models that contain multiple variants in one string
+    # Example: "Surface Pro 7+ and Surface Pro 7+ LTE"
+    $familyKeyCandidates = [System.Collections.Generic.List[string]]::new()
+    $familyKeySet = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
+
+    $primaryKey = ConvertTo-SurfaceComparableName -Text $ModelName
+    if (-not [string]::IsNullOrWhiteSpace($primaryKey) -and $familyKeySet.Add($primaryKey)) {
+        $familyKeyCandidates.Add($primaryKey) | Out-Null
+    }
+
+    $parts = [regex]::Split($ModelName, '(?i)\s+and\s+')
+
+    # Track when the model text contains both LTE and non-LTE variants (e.g. "Surface Go 2 and Surface Go 2 LTE")
+    $hasLtePart = (@($parts | Where-Object { $_ -match '(?i)\bLTE\b' }).Count -gt 0)
+    $hasNonLtePart = (@($parts | Where-Object { $_ -notmatch '(?i)\bLTE\b' }).Count -gt 0)
+
+    foreach ($part in @($parts)) {
+        if ([string]::IsNullOrWhiteSpace($part)) { continue }
+        $candidate = ConvertTo-SurfaceComparableName -Text $part
+        if (-not [string]::IsNullOrWhiteSpace($candidate) -and $familyKeySet.Add($candidate)) {
+            $familyKeyCandidates.Add($candidate) | Out-Null
+        }
+    }
+
+    if ($familyKeyCandidates.Count -eq 0) {
+        return @()
+    }
+
+    # Surface 3 has multiple carrier/region variants that share the same SystemModel ("Surface 3").
+    # Add a base key so we can match all Surface 3 SKU rows, then refine down to the correct variant.
+    if ($ModelName -match '(?i)^Surface\s+3\b') {
+        $surface3BaseKey = 'SURFACE 3'
+        if ($familyKeySet.Add($surface3BaseKey)) {
+            $familyKeyCandidates.Add($surface3BaseKey) | Out-Null
+        }
+    }
+
+    # Surface Go variants share the same SystemModel ("Surface Go") in the SKU table.
+    # Use a generation-aware base key so we don't cross-match Go vs Go 2/3/4 SKU rows.
+    if ($ModelName -match '(?i)^Surface\s+Go\s+2\b') {
+        $surfaceGoBaseKey = 'SURFACE GO 2'
+        if ($familyKeySet.Add($surfaceGoBaseKey)) {
+            $familyKeyCandidates.Add($surfaceGoBaseKey) | Out-Null
+        }
+    }
+    elseif ($ModelName -match '(?i)^Surface\s+Go\s+3\b') {
+        $surfaceGoBaseKey = 'SURFACE GO 3'
+        if ($familyKeySet.Add($surfaceGoBaseKey)) {
+            $familyKeyCandidates.Add($surfaceGoBaseKey) | Out-Null
+        }
+    }
+    elseif ($ModelName -match '(?i)^Surface\s+Go\s+4\b') {
+        $surfaceGoBaseKey = 'SURFACE GO 4'
+        if ($familyKeySet.Add($surfaceGoBaseKey)) {
+            $familyKeyCandidates.Add($surfaceGoBaseKey) | Out-Null
+        }
+    }
+    elseif ($ModelName -match '(?i)^Surface\s+Go\b') {
+        $surfaceGoBaseKey = 'SURFACE GO'
+        if ($familyKeySet.Add($surfaceGoBaseKey)) {
+            $familyKeyCandidates.Add($surfaceGoBaseKey) | Out-Null
+        }
+    }
+
+    # Surface Pro 9 with 5G: the SKU table rows use SystemModel "Surface Pro 9".
+    # Add a base key so we can match the Pro 9 SKU rows, then refine down to the 5G rows.
+    if (($ModelName -match '(?i)^Surface\s+Pro\s+9\b') -and ($ModelName -match '(?i)\b5G\b')) {
+        $surfacePro9BaseKey = 'SURFACE PRO 9'
+        if ($familyKeySet.Add($surfacePro9BaseKey)) {
+            $familyKeyCandidates.Add($surfacePro9BaseKey) | Out-Null
+        }
+    }
+
+    # Surface Pro with LTE Advanced maps to the "Surface Pro with LTE Advanced (5th Gen)" SKU table row.
+    # Add a base key so we can match Surface Pro rows, then refine to the LTE Advanced SKU.
+    if ($ModelName -match '(?i)^Surface\s+Pro\s+with\s+LTE\s+Advanced\b') {
+        $surfaceProBaseKey = 'SURFACE PRO'
+        if ($familyKeySet.Add($surfaceProBaseKey)) {
+            $familyKeyCandidates.Add($surfaceProBaseKey) | Out-Null
+        }
+    }
+
+    # Surface Laptop (1st Gen) maps to the base "Surface Laptop" SKU table row.
+    if (($ModelName -match '(?i)^Surface\s+Laptop\b') -and ($ModelName -match '(?i)\bGen\b')) {
+        $surfaceLaptopBaseKey = 'SURFACE LAPTOP'
+        if ($familyKeySet.Add($surfaceLaptopBaseKey)) {
+            $familyKeyCandidates.Add($surfaceLaptopBaseKey) | Out-Null
+        }
+    }
+
+    # Surface Studio (1st Gen) maps to the base "Surface Studio" SKU table row.
+    if (($ModelName -match '(?i)^Surface\s+Studio\b') -and ($ModelName -match '(?i)\bGen\b')) {
+        $surfaceStudioBaseKey = 'SURFACE STUDIO'
+        if ($familyKeySet.Add($surfaceStudioBaseKey)) {
+            $familyKeyCandidates.Add($surfaceStudioBaseKey) | Out-Null
+        }
+    }
+
+    # Surface Laptop 3/4 AMD/Intel packs map to the "Surface Laptop 3/4" SystemModel rows in the SKU table.
+    if ($ModelName -match '(?i)^Surface\s+Laptop\s+(3|4)\b' -and $ModelName -match '(?i)\b(AMD|Intel)\b') {
+        $generationMatch = [regex]::Match($ModelName, '(?i)^Surface\s+Laptop\s+(3|4)\b')
+        if ($generationMatch.Success) {
+            $surfaceLaptopGenBaseKey = "SURFACE LAPTOP $($generationMatch.Groups[1].Value)"
+            if ($familyKeySet.Add($surfaceLaptopGenBaseKey)) {
+                $familyKeyCandidates.Add($surfaceLaptopGenBaseKey) | Out-Null
+            }
+        }
+    }
+
+    # Match by any candidate key against the SKU table
+    $skuMatches = @($skuIndex | Where-Object {
+            $deviceKey = ConvertTo-SurfaceComparableName -Text $_.Device
+            $modelKey = ConvertTo-SurfaceComparableName -Text $_.SystemModel
+
+            foreach ($candidateKey in $familyKeyCandidates) {
+                if ($deviceKey -eq $candidateKey -or $modelKey -eq $candidateKey) {
+                    return $true
+                }
+            }
+
+            return $false
+        })
+
+    # Surface Hub 2 driver packs cover Surface Hub 2S + Surface Hub 3 devices.
+    # The System SKU table does not have a "Surface Hub 2" row, so map Hub 2 to all Hub SKUs.
+    if ($ModelName -match '(?i)^Surface\s+Hub\s+2\b') {
+        $hubSkuRows = @($skuIndex | Where-Object { $_.Device -match '(?i)^Surface\s+Hub' })
+        if ($hubSkuRows.Count -gt 0) {
+            $skuMatches = @($hubSkuRows)
+        }
+    }
+
+    # Surface 3: refine down to the correct SKU row based on the model variant text
+    # Use normalized text so punctuation/Unicode differences don't drop matches to zero.
+    if ($ModelName -match '(?i)^Surface\s+3\b') {
+        $modelNorm = ConvertTo-SurfaceComparableName -Text $ModelName
+
+        if ($modelNorm -match '(?i)\bWI\s+FI\b') {
+            $skuMatches = @($skuMatches | Where-Object { (ConvertTo-SurfaceComparableName -Text $_.Device) -match '(?i)\bWI\s+FI\b' })
+        }
+        elseif ($modelNorm -match '(?i)\bVERIZON\b') {
+            $skuMatches = @($skuMatches | Where-Object { (ConvertTo-SurfaceComparableName -Text $_.Device) -match '(?i)\bVERIZON\b' })
+        }
+        elseif ($modelNorm -match '(?i)\bOUTSIDE\s+OF\s+NORTH\s+AMERICA\b|\bY\s+MOBILE\b') {
+            $skuMatches = @($skuMatches | Where-Object { (ConvertTo-SurfaceComparableName -Text $_.Device) -match '(?i)\bOUTSIDE\s+OF\s+NORTH\s+AMERICA\b|\bY\s+MOBILE\b' })
+        }
+        elseif ($modelNorm -match '(?i)\bNORTH\s+AMERICA\b') {
+            # "North America (non-AT&T)" should map to the North America row (not AT&T/Verizon/outside-of-North-America)
+            $skuMatches = @($skuMatches | Where-Object {
+                    $deviceNorm = ConvertTo-SurfaceComparableName -Text $_.Device
+                    ($deviceNorm -match '(?i)\bNORTH\s+AMERICA\b') -and
+                    ($deviceNorm -notmatch '(?i)\bOUTSIDE\b|\bY\s+MOBILE\b') -and
+                    ($deviceNorm -notmatch '(?i)\bAT\s+T\b|\bVERIZON\b')
+                })
+        }
+        elseif (($modelNorm -match '(?i)\bAT\s+T\b') -and ($modelNorm -notmatch '(?i)\bNON\s+AT\s+T\b')) {
+            $skuMatches = @($skuMatches | Where-Object { (ConvertTo-SurfaceComparableName -Text $_.Device) -match '(?i)\bAT\s+T\b' })
+        }
+    }
+
+    # Surface Go: keep LTE SKU only for LTE-only models; exclude LTE SKU for non-LTE-only models.
+    # If the model name includes BOTH LTE and non-LTE variants (joined with "and"), do not filter.
+    # Surface Go 3 driver packs are treated as covering LTE + non-LTE unless explicitly labeled otherwise.
+    if ($ModelName -match '(?i)^Surface\s+Go\b') {
+        $isSurfaceGo3Base = ($ModelName -match '(?i)^Surface\s+Go\s+3\b') -and ($ModelName -notmatch '(?i)\bLTE\b')
+
+        if (-not $isSurfaceGo3Base) {
+            if (-not ($hasLtePart -and $hasNonLtePart)) {
+                if ($ModelName -match '(?i)\bLTE\b') {
+                    $skuMatches = @($skuMatches | Where-Object { $_.Device -match '(?i)\bLTE\b' })
+                }
+                else {
+                    $skuMatches = @($skuMatches | Where-Object { $_.Device -notmatch '(?i)\bLTE\b' })
+                }
+            }
+        }
+    }
+
+    # Surface Pro 9 with 5G (SQ3): keep only the 5G SKU rows (U.S. + outside of U.S.).
+    if (($ModelName -match '(?i)^Surface\s+Pro\s+9\b') -and ($ModelName -match '(?i)\b5G\b')) {
+        $skuMatches = @($skuMatches | Where-Object { $_.Device -match '(?i)\b5G\b' })
+    }
+
+    # Surface Pro 10: split non-5G vs 5G SKU rows so the two driver packs don't share the same SystemSKUs.
+    if ($ModelName -match '(?i)^Surface\s+Pro\s+10\b') {
+        if ($ModelName -match '(?i)\b5G\b') {
+            $skuMatches = @($skuMatches | Where-Object {
+                    ($_.SystemSku -match '^SURFACE_PRO_10_WITH_5G_FOR_BUSINESS_') -or
+                    ($_.Device -match '(?i)\bwith\s+5G\b')
+                })
+        }
+        else {
+            $skuMatches = @($skuMatches | Where-Object { $_.SystemSku -eq 'SURFACE_PRO_10_FOR_BUSINESS_2079' })
+        }
+    }
+
+    # Surface Pro with LTE Advanced: restrict to the LTE Advanced (5th Gen) SKU.
+    if ($ModelName -match '(?i)^Surface\s+Pro\s+with\s+LTE\s+Advanced\b') {
+        $skuMatches = @($skuMatches | Where-Object { $_.SystemSku -eq 'SURFACE_PRO_1807' })
+    }
+
+    # Surface Laptop 3/4: filter to AMD vs Intel rows (prevents AMD packs from inheriting Intel SKUs and vice-versa).
+    if ($ModelName -match '(?i)^Surface\s+Laptop\s+(3|4)\b') {
+        if ($ModelName -match '(?i)\bAMD\b') {
+            $skuMatches = @($skuMatches | Where-Object { $_.Device -match '(?i)\bAMD\b' })
+        }
+        elseif ($ModelName -match '(?i)\bIntel\b') {
+            $skuMatches = @($skuMatches | Where-Object { $_.Device -match '(?i)\bIntel\b' })
+        }
+    }
+
+    # Apply architecture filtering when we can infer it
+    if ($archHint -eq 'ARM64') {
+        # ARM variants are typically called out as Snapdragon / SQ3 / 5G in the Learn table
+        $skuMatches = @($skuMatches | Where-Object {
+                ($_.Device -match '(?i)Snapdragon|SQ3|with 5G') -or
+                ($_.SystemModel -match '(?i)Snapdragon|SQ3|with 5G')
+            })
+    }
+    elseif ($archHint -eq 'x64') {
+        # x64 variants are often NOT labeled "Intel" in the Learn table (e.g. Surface Pro 9).
+        # Treat "not Snapdragon/SQ3/5G" as the x64 bucket.
+        $skuMatches = @($skuMatches | Where-Object {
+                ($_.Device -notmatch '(?i)Snapdragon|SQ3|with 5G') -and
+                ($_.SystemModel -notmatch '(?i)Snapdragon|SQ3|with 5G')
+            })
+    }
+
+    $skus = @($skuMatches | ForEach-Object { $_.SystemSku } | Where-Object { -not [string]::IsNullOrWhiteSpace($_) } | Sort-Object -Unique)
+    return $skus
+}
+
+Export-ModuleMember -Function `
+    Get-SurfaceDriverIndexCachePath, `
+    Import-SurfaceDriverIndexCache, `
+    Save-SurfaceDriverIndexCache, `
+    ConvertTo-SurfaceComparableName, `
+    Get-SurfaceSystemSkuReferenceIndex, `
+    Get-SurfaceDownloadCenterDetails, `
+    Get-SurfaceSystemSkuListForMicrosoftDriver

FFUDevelopment/FFU.Common/FFU.Common.Drivers.psm1

@@ -22,7 +22,10 @@ function Compress-DriverFolderToWim {
         [string]$WimName, # Optional, defaults to folder name
 
         [Parameter()]
-        [string]$WimDescription # Optional, defaults to folder name
+        [string]$WimDescription, # Optional, defaults to folder name
+
+        [Parameter()]
+        [bool]$PreserveSource = $false # When $true, do not delete source folder; create marker for deferred cleanup
     )
 
     WriteLog "Starting compression of folder '$SourceFolderPath' to '$DestinationWimPath'."
@@ -66,14 +69,29 @@ function Compress-DriverFolderToWim {
             WriteLog "Successfully compressed '$SourceFolderPath' to '$DestinationWimPath' using dism.exe."
             
             # Remove the source folder after successful compression
-            WriteLog "Removing source driver folder: $SourceFolderPath"
-            try {
-                Remove-Item -Path $SourceFolderPath -Recurse -Force -ErrorAction Stop
-                WriteLog "Successfully removed source folder '$SourceFolderPath'."
+            if ($PreserveSource) {
+                WriteLog "Preserving source driver folder for deferred WinPE driver harvesting: $SourceFolderPath"
+                try {
+                    $markerFile = Join-Path -Path $SourceFolderPath -ChildPath '__PreservedForPEDrivers.txt'
+                    if (-not (Test-Path -Path $markerFile -PathType Leaf)) {
+                        New-Item -Path $markerFile -ItemType File -Force | Out-Null
+                        WriteLog "Created preservation marker file: $markerFile"
+                    }
+                }
+                catch {
+                    WriteLog "Warning: Failed to create preservation marker in $SourceFolderPath. Error: $($_.Exception.Message)"
+                }
             }
-            catch {
-                WriteLog "Warning: Failed to remove source folder '$SourceFolderPath'. Error: $($_.Exception.Message)"
-                # Do not fail the whole operation, just log a warning.
+            else {
+                WriteLog "Removing source driver folder: $SourceFolderPath"
+                try {
+                    Remove-Item -Path $SourceFolderPath -Recurse -Force -ErrorAction Stop
+                    WriteLog "Successfully removed source folder '$SourceFolderPath'."
+                }
+                catch {
+                    WriteLog "Warning: Failed to remove source folder '$SourceFolderPath'. Error: $($_.Exception.Message)"
+                    # Do not fail the whole operation, just log a warning.
+                }
             }
 
             return $true # Indicate success
@@ -137,31 +155,222 @@ function Update-DriverMappingJson {
     $updatedCount = 0
     $addedCount = 0
 
+    $hpSystemIdCache = @{}
+    $normalizeHpName = {
+        param([string]$text)
+
+        if ([string]::IsNullOrWhiteSpace($text)) {
+            return $null
+        }
+
+        return ([regex]::Replace($text.ToLowerInvariant(), '[^a-z0-9]', ''))
+    }
+    $getHpSystemId = {
+        param([string]$modelName)
+
+        if ([string]::IsNullOrWhiteSpace($modelName)) {
+            return $null
+        }
+
+        if ($hpSystemIdCache.ContainsKey($modelName)) {
+            return $hpSystemIdCache[$modelName]
+        }
+
+        $hpFolder = Join-Path -Path $DriversFolder -ChildPath 'HP'
+        if (-not (Test-Path -Path $hpFolder -PathType Container)) {
+            $hpSystemIdCache[$modelName] = $null
+            return $null
+        }
+
+        $platformListXml = Join-Path -Path $hpFolder -ChildPath 'PlatformList.xml'
+        $platformListCab = Join-Path -Path $hpFolder -ChildPath 'platformList.cab'
+        if (-not (Test-Path -Path $platformListXml -PathType Leaf)) {
+            try {
+                WriteLog "Attempting to refresh HP PlatformList.xml for SystemID lookup."
+                Start-BitsTransferWithRetry -Source 'https://hpia.hpcloud.hp.com/ref/platformList.cab' -Destination $platformListCab -ErrorAction Stop
+                if (Test-Path -Path $platformListXml) { Remove-Item -Path $platformListXml -Force -ErrorAction SilentlyContinue }
+                Invoke-Process -FilePath "expand.exe" -ArgumentList @("`"$platformListCab`"", "`"$platformListXml`"") -ErrorAction Stop | Out-Null
+                if (Test-Path -Path $platformListCab) { Remove-Item -Path $platformListCab -Force -ErrorAction SilentlyContinue }
+            }
+            catch {
+                WriteLog "Failed to refresh HP PlatformList.xml: $($_.Exception.Message)"
+                $hpSystemIdCache[$modelName] = $null
+                return $null
+            }
+        }
+
+        try {
+            [xml]$platformListContent = Get-Content -Path $platformListXml -Raw -Encoding UTF8 -ErrorAction Stop
+
+            $targetName = $modelName.Trim()
+            $normalizedTarget = & $normalizeHpName $targetName
+
+            $modelMatch = $platformListContent.ImagePal.Platform | Where-Object {
+                [string]::Equals($_.ProductName.'#text'.Trim(), $targetName, [System.StringComparison]::OrdinalIgnoreCase)
+            } | Select-Object -First 1
+
+            if (-not $modelMatch -and $normalizedTarget) {
+                $modelMatch = $platformListContent.ImagePal.Platform | Where-Object {
+                    $candidateName = $_.ProductName.'#text'
+                    $normalizedCandidate = & $normalizeHpName $candidateName
+                    $normalizedCandidate -eq $normalizedTarget
+                } | Select-Object -First 1
+            }
+
+            if (-not $modelMatch -and $normalizedTarget) {
+                $modelMatch = $platformListContent.ImagePal.Platform | Where-Object {
+                    $candidateName = $_.ProductName.'#text'
+                    $normalizedCandidate = & $normalizeHpName $candidateName
+                    ($normalizedCandidate -like "*$normalizedTarget*") -or ($normalizedTarget -like "*$normalizedCandidate*")
+                } | Select-Object -First 1
+            }
+
+            if ($modelMatch -and -not [string]::IsNullOrWhiteSpace($modelMatch.SystemID)) {
+                $resolvedId = $modelMatch.SystemID.Trim().ToUpperInvariant()
+                $hpSystemIdCache[$modelName] = $resolvedId
+                return $resolvedId
+            }
+            else {
+                WriteLog "HP SystemId lookup: no match found in PlatformList.xml for model '$modelName'."
+            }
+        }
+        catch {
+            WriteLog "Failed to parse HP PlatformList.xml for model '$modelName': $($_.Exception.Message)"
+        }
+
+        $hpSystemIdCache[$modelName] = $null
+        return $null
+    }
+
     foreach ($driver in $DownloadedDrivers) {
-        # Skip if any required property is missing or null
         if (-not $driver.PSObject.Properties['Make'] -or -not $driver.PSObject.Properties['Model'] -or -not $driver.PSObject.Properties['DriverPath'] -or [string]::IsNullOrWhiteSpace($driver.DriverPath)) {
             WriteLog "Skipping driver entry due to missing or empty Make, Model, or DriverPath. Details: $(($driver | ConvertTo-Json -Compress -Depth 3))"
             continue
         }
 
-        # Find existing entry
+        $systemIdValue = $null
+        $machineTypeValue = $null
+
+        if ($driver.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($driver.SystemId)) {
+            $systemIdValue = $driver.SystemId.Trim().ToUpperInvariant()
+        }
+        if ($driver.PSObject.Properties['MachineType'] -and -not [string]::IsNullOrWhiteSpace($driver.MachineType)) {
+            $machineTypeValue = $driver.MachineType.Trim()
+        }
+
+        switch ($driver.Make) {
+            'Dell' {
+                if (-not $systemIdValue -and $driver.Model -match '\(([^)]+)\)\s*$') {
+                    $systemIdValue = $matches[1].Trim().ToUpperInvariant()
+                }
+            }
+            'HP' {
+                if (-not $systemIdValue) {
+                    $systemIdValue = & $getHpSystemId $driver.Model
+                }
+            }
+            'Lenovo' {
+                if (-not $machineTypeValue -and $driver.Model -match '\(([^)]+)\)\s*$') {
+                    $machineTypeValue = $matches[1].Trim()
+                }
+            }
+        }
+
+        # Microsoft Surface: resolve System SKU list (best-effort) using Sources A + C and cached results
+        $surfaceSystemSkuList = @()
+        if ($driver.Make -eq 'Microsoft') {
+            if ($driver.PSObject.Properties['Link'] -and -not [string]::IsNullOrWhiteSpace($driver.Link)) {
+                try {
+                    $surfaceSystemSkuList = Get-SurfaceSystemSkuListForMicrosoftDriver -DriversFolder $DriversFolder -ModelName $driver.Model -ModelLink $driver.Link
+                }
+                catch {
+                    WriteLog "Warning: Failed to resolve Surface SystemSku list for '$($driver.Model)'. Error: $($_.Exception.Message)"
+                    $surfaceSystemSkuList = @()
+                }
+            }
+        }
+
         $existingEntry = $mappingList | Where-Object { $_.Manufacturer -eq $driver.Make -and $_.Model -eq $driver.Model } | Select-Object -First 1
 
         if ($null -ne $existingEntry) {
-            # Update existing entry if the path is different
+            $entryUpdated = $false
             if ($existingEntry.DriverPath -ne $driver.DriverPath) {
                 WriteLog "Updating driver path for '$($driver.Make) - $($driver.Model)' from '$($existingEntry.DriverPath)' to '$($driver.DriverPath)'."
                 $existingEntry.DriverPath = $driver.DriverPath
+                $entryUpdated = $true
+            }
+
+            if ($driver.Make -in @('HP', 'Dell') -and -not [string]::IsNullOrWhiteSpace($systemIdValue)) {
+                if ($existingEntry.PSObject.Properties['SystemId']) {
+                    if ($existingEntry.SystemId -ne $systemIdValue) {
+                        WriteLog "Updating SystemId for '$($driver.Make) - $($driver.Model)' to '$systemIdValue'."
+                        $existingEntry.SystemId = $systemIdValue
+                        $entryUpdated = $true
+                    }
+                }
+                else {
+                    WriteLog "Adding SystemId '$systemIdValue' for '$($driver.Make) - $($driver.Model)'."
+                    $existingEntry | Add-Member -NotePropertyName SystemId -NotePropertyValue $systemIdValue
+                    $entryUpdated = $true
+                }
+            }
+
+            if ($driver.Make -eq 'Lenovo' -and -not [string]::IsNullOrWhiteSpace($machineTypeValue)) {
+                if ($existingEntry.PSObject.Properties['MachineType']) {
+                    if ($existingEntry.MachineType -ne $machineTypeValue) {
+                        WriteLog "Updating MachineType for '$($driver.Make) - $($driver.Model)' to '$machineTypeValue'."
+                        $existingEntry.MachineType = $machineTypeValue
+                        $entryUpdated = $true
+                    }
+                }
+                else {
+                    WriteLog "Adding MachineType '$machineTypeValue' for '$($driver.Make) - $($driver.Model)'."
+                    $existingEntry | Add-Member -NotePropertyName MachineType -NotePropertyValue $machineTypeValue
+                    $entryUpdated = $true
+                }
+            }
+
+            if ($driver.Make -eq 'Microsoft' -and $surfaceSystemSkuList -and $surfaceSystemSkuList.Count -gt 0) {
+                $desiredSkus = @($surfaceSystemSkuList | Sort-Object -Unique)
+                if ($existingEntry.PSObject.Properties['SystemSku']) {
+                    $currentSkus = @($existingEntry.SystemSku)
+                    $currentNormalized = @($currentSkus | ForEach-Object { if ($null -ne $_) { $_.ToString().Trim().ToUpperInvariant() } }) | Sort-Object -Unique
+                    $desiredNormalized = @($desiredSkus | ForEach-Object { if ($null -ne $_) { $_.ToString().Trim().ToUpperInvariant() } }) | Sort-Object -Unique
+
+                    if (($currentNormalized -join '|') -ne ($desiredNormalized -join '|')) {
+                        WriteLog "Updating SystemSku list for 'Microsoft - $($driver.Model)'."
+                        $existingEntry.SystemSku = $desiredSkus
+                        $entryUpdated = $true
+                    }
+                }
+                else {
+                    WriteLog "Adding SystemSku list for 'Microsoft - $($driver.Model)'."
+                    $existingEntry | Add-Member -NotePropertyName SystemSku -NotePropertyValue $desiredSkus
+                    $entryUpdated = $true
+                }
+            }
+
+            if ($entryUpdated) {
                 $updatedCount++
             }
         }
         else {
-            # Add new entry
             $newEntry = [PSCustomObject]@{
                 Manufacturer = $driver.Make
                 Model        = $driver.Model
                 DriverPath   = $driver.DriverPath
             }
+
+            if ($driver.Make -in @('HP', 'Dell') -and -not [string]::IsNullOrWhiteSpace($systemIdValue)) {
+                $newEntry | Add-Member -NotePropertyName SystemId -NotePropertyValue $systemIdValue
+            }
+            if ($driver.Make -eq 'Lenovo' -and -not [string]::IsNullOrWhiteSpace($machineTypeValue)) {
+                $newEntry | Add-Member -NotePropertyName MachineType -NotePropertyValue $machineTypeValue
+            }
+            if ($driver.Make -eq 'Microsoft' -and $surfaceSystemSkuList -and $surfaceSystemSkuList.Count -gt 0) {
+                $newEntry | Add-Member -NotePropertyName SystemSku -NotePropertyValue @($surfaceSystemSkuList | Sort-Object -Unique)
+            }
+
             $mappingList.Add($newEntry)
             WriteLog "Adding new mapping for '$($driver.Make) - $($driver.Model)' with path '$($driver.DriverPath)'."
             $addedCount++
@@ -274,111 +483,328 @@ function Get-LenovoPSREFToken {
         if your alternative works is to see if you can retrieve 100e, 300w, 500w, etc. These don't show up in catalogv2.xml, but they do in PSREF.
     #>
 
-    # Path to Edge
-    $edgeExe = "$Env:ProgramFiles (x86)\Microsoft\Edge\Application\msedge.exe"
+    $token = $null
+    $socket = $null
+    $edgeProcess = $null
+    $tempProfile = $null
+    $port = $null
 
-    # Any free port works. 9222 is common.
-    $port = 9222
-    $uri = 'https://psref.lenovo.com'
-
-    # Headless run with remote debugging.
-    $flags = "--headless=new --disable-gpu --remote-debugging-port=$port $uri"
-    $edge = Start-Process -FilePath $edgeExe -ArgumentList $flags -PassThru
-    Writelog "Edge process started with PID: $($edge.Id)."
-
-    # Wait a short moment so the target appears.
-    Start-Sleep -Seconds 3
-
-    # Find the first page target.
-    $targets = Invoke-RestMethod "http://localhost:$port/json"
-    $wsUrl = ($targets | Where-Object type -eq 'page')[0].webSocketDebuggerUrl
-
-    # Connect to that WebSocket.
-    $socket = [System.Net.WebSockets.ClientWebSocket]::new()
-    $socket.ConnectAsync($wsUrl, [Threading.CancellationToken]::None).Wait()
-
-    # Helper to send a DevTools command.
-    function Send-DevToolsCommand {
-        param([int]$id, [string]$method, [hashtable]$params = @{})
-        $cmd = @{ id = $id; method = $method; params = $params } |
-        ConvertTo-Json -Compress
-        $data = [Text.Encoding]::UTF8.GetBytes($cmd)
-        $socket.SendAsync([ArraySegment[byte]]$data, 'Text', $true,
-            [Threading.CancellationToken]::None).Wait()
+    function Get-FreeLocalTcpPort {
+        $listener = $null
+        try {
+            $listener = [System.Net.Sockets.TcpListener]::new([System.Net.IPAddress]::Loopback, 0)
+            $listener.Start()
+            $endpoint = [System.Net.IPEndPoint]$listener.LocalEndpoint
+            return $endpoint.Port
+        }
+        finally {
+            if ($null -ne $listener) {
+                $listener.Stop()
+            }
+        }
     }
 
-    # Ask the page to return localStorage['asut'].
-    Send-DevToolsCommand -id 1 -method 'Runtime.evaluate' -params @{
-        expression = "localStorage.getItem('asut')"
+    function Get-EdgeDevToolsPageTarget {
+        param(
+            [Parameter(Mandatory = $true)][int]$Port,
+            [int]$MaxAttempts = 20,
+            [int]$DelayMilliseconds = 500,
+            [string]$UrlContains
+        )
+
+        for ($attempt = 1; $attempt -le $MaxAttempts; $attempt++) {
+            try {
+                $targets = Invoke-RestMethod -Uri "http://localhost:$Port/json" -ErrorAction Stop
+                if ($null -ne $targets) {
+                    if ($targets -isnot [System.Array]) { $targets = @($targets) }
+                    $pageTargets = $targets | Where-Object { $_.type -eq 'page' }
+                    if (-not [string]::IsNullOrWhiteSpace($UrlContains)) {
+                        $pageTargets = $pageTargets | Where-Object {
+                            -not [string]::IsNullOrWhiteSpace($_.url) -and $_.url -like "*$UrlContains*"
+                        }
+                    }
+
+                    $target = $pageTargets | Select-Object -First 1
+                    if ($null -ne $target) {
+                        return $target
+                    }
+
+                    WriteLog "DevTools endpoint on port $Port returned targets but no page matched the criteria (attempt $attempt of $MaxAttempts)."
+                }
+                else {
+                    WriteLog "DevTools endpoint on port $Port returned no targets (attempt $attempt of $MaxAttempts)."
+                }
+            }
+            catch {
+                WriteLog "DevTools endpoint on port $Port not ready (attempt $attempt of $MaxAttempts). Error: $($_.Exception.Message)"
+            }
+
+            Start-Sleep -Milliseconds $DelayMilliseconds
+        }
+
+        throw "Edge DevTools endpoint on port $Port did not expose a matching page target after $MaxAttempts attempts."
     }
 
-    # Receive frames until the whole message arrives.
-    $ms = New-Object System.IO.MemoryStream
-    $buf = New-Object byte[] 8192
-    do {
-        $seg = [ArraySegment[byte]]::new($buf)
-        $res = $socket.ReceiveAsync($seg,
-            [Threading.CancellationToken]::None).Result
-        $ms.Write($buf, 0, $res.Count)
-    } until ($res.EndOfMessage)
-
-    $ms.Position = 0
-    $json = ([System.IO.StreamReader]::new($ms, [Text.Encoding]::UTF8)).ReadToEnd() |
-    ConvertFrom-Json
-
-    $token = $json.result.result.value
-    # Concatenate the token value with X-PSREF-USER-TOKEN=
-    $token = "X-PSREF-USER-TOKEN=$token"
-    WriteLog "Retrieved Lenovo PSREF token: $token"
-
-    # Clean up.
-    $socket.Dispose()
-
-    if ($null -ne $socket) {
-        $socket.Dispose()
-    }
-
-    # Find the PID listening on the debugging port for reliable termination.
-    $listeningPid = $null
     try {
-        # Find the process listening on the specific port. The regex now looks for the local address and port, followed by anything, then LISTENING.
-        # Dots are escaped for literal matching.
-        $netstatOutput = netstat -ano -p TCP | Where-Object { $_ -match "127\.0\.0\.1:$port.*LISTENING" }
-        if ($netstatOutput) {
-            # The last number in the line is the PID
-            $listeningPid = ($netstatOutput -split '\s+')[-1]
-            WriteLog "Found Edge process PID $listeningPid listening on port $port. This is the process we will terminate."
+        $ffuDevelopmentRoot = Split-Path -Path $PSScriptRoot -Parent
+        WriteLog "Derived FFUDevelopmentPath from module path: $ffuDevelopmentRoot"
+
+        if ([string]::IsNullOrWhiteSpace($ffuDevelopmentRoot)) {
+            throw "FFUDevelopmentPath could not be resolved. Unable to create Edge profile."
         }
-        else {
-            WriteLog "Could not find any process listening on port $port."
+
+        if (-not (Test-Path -Path $ffuDevelopmentRoot -PathType Container)) {
+            throw "Resolved FFUDevelopmentPath '$ffuDevelopmentRoot' does not exist."
         }
+
+        $tempProfile = Join-Path -Path $ffuDevelopmentRoot -ChildPath ("edge-psref-" + [guid]::NewGuid())
+        WriteLog "Creating temporary Edge profile at $tempProfile."
+        New-Item -ItemType Directory -Path $tempProfile -Force | Out-Null
+
+        $edgeExe = "$Env:ProgramFiles (x86)\Microsoft\Edge\Application\msedge.exe"
+        $uri = 'https://psref.lenovo.com'
+        $port = Get-FreeLocalTcpPort
+        WriteLog "Using Edge DevTools port $port for Lenovo PSREF token retrieval."
+
+        $flags = "--headless=new --disable-gpu --remote-debugging-port=$port $uri --user-data-dir=`"$tempProfile`""
+        $edgeProcess = Start-Process -FilePath $edgeExe -ArgumentList $flags -PassThru
+        WriteLog "Edge process started with PID: $($edgeProcess.Id)."
+
+        $pageTarget = Get-EdgeDevToolsPageTarget -Port $port -MaxAttempts 40 -DelayMilliseconds 500 -UrlContains 'psref.lenovo.com'
+        if (-not [string]::IsNullOrWhiteSpace($pageTarget.url)) {
+            WriteLog "Selected DevTools target URL: $($pageTarget.url)"
+        }
+
+        $wsUrl = $pageTarget.webSocketDebuggerUrl
+        if ([string]::IsNullOrWhiteSpace($wsUrl)) {
+            throw "Edge DevTools page target on port $port did not provide a WebSocket URL."
+        }
+
+        $socket = [System.Net.WebSockets.ClientWebSocket]::new()
+        $socket.ConnectAsync($wsUrl, [Threading.CancellationToken]::None).Wait()
+
+        function Send-DevToolsCommand {
+            param([int]$id, [string]$method, [hashtable]$params = @{})
+            $cmd = @{ id = $id; method = $method; params = $params } | ConvertTo-Json -Compress
+            $data = [Text.Encoding]::UTF8.GetBytes($cmd)
+            $socket.SendAsync([ArraySegment[byte]]$data, 'Text', $true, [Threading.CancellationToken]::None).Wait()
+        }
+
+        $buffer = New-Object byte[] 8192
+
+        function Invoke-DevToolsValue {
+            param(
+                [Parameter(Mandatory = $true)][int]$CommandId,
+                [Parameter(Mandatory = $true)][string]$Expression,
+                [int]$MaxPolls = 25
+            )
+
+            Send-DevToolsCommand -id $CommandId -method 'Runtime.evaluate' -params @{
+                expression    = $Expression
+                returnByValue = $true
+                awaitPromise  = $true
+            }
+
+            for ($poll = 1; $poll -le $MaxPolls; $poll++) {
+                $localStream = $null
+                try {
+                    $localStream = New-Object System.IO.MemoryStream
+                    do {
+                        $segment = [ArraySegment[byte]]::new($buffer)
+                        $result = $socket.ReceiveAsync($segment, [Threading.CancellationToken]::None).Result
+                        $localStream.Write($buffer, 0, $result.Count)
+                    } until ($result.EndOfMessage)
+
+                    $jsonBytes = $localStream.ToArray()
+                    $jsonText = [Text.Encoding]::UTF8.GetString($jsonBytes)
+                    $previewPayload = $jsonText
+                    if (-not [string]::IsNullOrEmpty($previewPayload) -and $previewPayload.Length -gt 500) {
+                        $previewPayload = $previewPayload.Substring(0, 500) + '...'
+                    }
+                    WriteLog "DevTools eval payload (cmd $CommandId, poll $poll): $previewPayload"
+
+                    $message = $null
+                    try {
+                        $message = $jsonText | ConvertFrom-Json
+                    }
+                    catch {
+                        WriteLog "Failed to parse DevTools eval payload for command id $CommandId (poll $poll): $($_.Exception.Message)"
+                        continue
+                    }
+
+                    if ($message.PSObject.Properties['id'] -and $message.id -eq $CommandId) {
+                        if ($message.PSObject.Properties['error']) {
+                            $errorMessage = $message.error.message
+                            throw "Edge DevTools reported an error for expression '$Expression': $errorMessage"
+                        }
+
+                        if ($message.PSObject.Properties['result'] -and $message.result.PSObject.Properties['result']) {
+                            $innerResult = $message.result.result
+                            return [PSCustomObject]@{
+                                Value   = $innerResult.value
+                                Type    = $innerResult.type
+                                Subtype = $innerResult.subtype
+                            }
+                        }
+
+                        $serializedMessage = $message | ConvertTo-Json -Compress -Depth 5
+                        WriteLog "DevTools response for command id $CommandId lacked result data. Message: $serializedMessage"
+                        return $null
+                    }
+
+                    if ($message.PSObject.Properties['method']) {
+                        WriteLog "Received DevTools event '$($message.method)' while waiting for command id $CommandId."
+                    }
+                    else {
+                        WriteLog "Received DevTools message without id or method while waiting for command id $CommandId."
+                    }
+                }
+                finally {
+                    if ($null -ne $localStream) {
+                        $localStream.Dispose()
+                    }
+                }
+            }
+
+            throw "No DevTools response received for command id $CommandId after $MaxPolls polls."
+        }
+
+        WriteLog "Waiting for PSREF page to initialize local storage context."
+        Start-Sleep -Seconds 2
+
+        $commandCounter = 1000
+        $rawToken = $null
+        $maxTokenAttempts = 12
+        for ($attempt = 1; $attempt -le $maxTokenAttempts -and [string]::IsNullOrWhiteSpace($rawToken); $attempt++) {
+            $commandCounter++
+            $tokenResponse = Invoke-DevToolsValue -CommandId $commandCounter -Expression "window.localStorage?.getItem('asut')" -MaxPolls 25
+            if ($null -ne $tokenResponse -and -not [string]::IsNullOrWhiteSpace($tokenResponse.Value)) {
+                $rawToken = $tokenResponse.Value
+                WriteLog "DevTools response for command id $commandCounter returned token length $($rawToken.Length)."
+                break
+            }
+
+            WriteLog "Lenovo PSREF token not yet available (attempt $attempt of $maxTokenAttempts)."
+
+            $commandCounter++
+            $keysResponse = Invoke-DevToolsValue -CommandId $commandCounter -Expression "JSON.stringify(Object.keys(window.localStorage || {}))" -MaxPolls 10
+            if ($null -ne $keysResponse -and -not [string]::IsNullOrWhiteSpace($keysResponse.Value)) {
+                WriteLog "Current localStorage keys: $($keysResponse.Value)"
+            }
+
+            $commandCounter++
+            $cookieResponse = Invoke-DevToolsValue -CommandId $commandCounter -Expression "document.cookie" -MaxPolls 10
+            if ($null -ne $cookieResponse -and -not [string]::IsNullOrWhiteSpace($cookieResponse.Value)) {
+                WriteLog "document.cookie contents: $($cookieResponse.Value)"
+                $cookieEntry = ($cookieResponse.Value -split ';') | ForEach-Object { $_.Trim() } | Where-Object { $_ -like 'asut=*' } | Select-Object -First 1
+                if ($cookieEntry) {
+                    $rawToken = $cookieEntry.Substring($cookieEntry.IndexOf('=') + 1)
+                    WriteLog "Extracted Lenovo PSREF token from cookies with length $($rawToken.Length)."
+                    break
+                }
+            }
+
+            Start-Sleep -Milliseconds 750
+        }
+
+        if ([string]::IsNullOrWhiteSpace($rawToken)) {
+            throw "Received empty Lenovo PSREF token from Edge DevTools after $maxTokenAttempts attempts."
+        }
+
+        $token = "X-PSREF-USER-TOKEN=$rawToken"
+        WriteLog "Retrieved Lenovo PSREF token: $token"
     }
     catch {
-        WriteLog "Could not run netstat to find listening PID. Error: $($_.Exception.Message)"
+        WriteLog "Failed to retrieve Lenovo PSREF token. Error: $($_.Exception.Message)"
+        throw
     }
-
-    # Determine the correct PID to kill. Prioritize the one found via netstat.
-    $pidToKill = $null
-    if ($listeningPid) {
-        $pidToKill = $listeningPid
-    }
-    elseif ($null -ne $edgeProcess -and -not $edgeProcess.HasExited) {
-        $pidToKill = $edgeProcess.Id
-        WriteLog "Could not find listening process via netstat. Falling back to initial Edge process PID $($pidToKill) for termination."
-    }
-
-    if ($pidToKill) {
-        WriteLog "Attempting to terminate Edge process tree with PID: $pidToKill"
-        try {
-            taskkill /PID $pidToKill /T /F | Out-Null
-            WriteLog "Successfully issued termination command for Edge process tree with PID: $pidToKill."
+    finally {
+        if ($null -ne $socket) {
+            try {
+                $socket.Dispose()
+                WriteLog "Edge DevTools WebSocket disposed."
+            }
+            catch {
+                WriteLog "Error disposing Edge DevTools WebSocket: $($_.Exception.Message)"
+            }
         }
-        catch {
-            WriteLog "Failed to terminate Edge process tree with PID: $pidToKill. It may have already closed. Error: $($_.Exception.Message)"
+
+        $listeningPid = $null
+        if ($null -ne $port) {
+            try {
+                $netstatOutput = netstat -ano -p TCP | Where-Object { $_ -match "127\.0\.0\.1:$port.*LISTENING" }
+                if ($netstatOutput) {
+                    $listeningPid = ($netstatOutput -split '\s+')[-1]
+                    WriteLog "Found Edge process PID $listeningPid listening on port $port."
+                }
+                else {
+                    WriteLog "No process reported as listening on port $port."
+                }
+            }
+            catch {
+                WriteLog "Could not run netstat to find listening PID for port $port. Error: $($_.Exception.Message)"
+            }
+        }
+
+        $pidToKill = $null
+        if ($null -ne $listeningPid) {
+            $pidToKill = $listeningPid
+        }
+        elseif ($null -ne $edgeProcess -and -not $edgeProcess.HasExited) {
+            $pidToKill = $edgeProcess.Id
+            WriteLog "Falling back to initial Edge process PID $pidToKill for termination."
+        }
+
+        if ($null -ne $pidToKill) {
+            try {
+                taskkill /PID $pidToKill /T /F | Out-Null
+                WriteLog "Issued termination command for Edge process tree with PID: $pidToKill."
+            }
+            catch {
+                WriteLog "Failed to terminate Edge process tree with PID: $pidToKill. Error: $($_.Exception.Message)"
+            }
+        }
+        else {
+            WriteLog "No active Edge process found to terminate."
+        }
+
+        if ($null -ne $edgeProcess) {
+            try {
+                $edgeProcess.WaitForExit(3000) | Out-Null
+            }
+            catch {
+                WriteLog "Error while waiting for Edge process PID $($edgeProcess.Id) to exit: $($_.Exception.Message)"
+            }
+        }
+
+        Start-Sleep -Milliseconds 250
+
+        if (-not [string]::IsNullOrWhiteSpace($tempProfile) -and (Test-Path -Path $tempProfile -PathType Container)) {
+            $maxRemoveAttempts = 5
+            $originalProgressPreference = $ProgressPreference
+            try {
+                $ProgressPreference = 'SilentlyContinue'
+                for ($removeAttempt = 1; $removeAttempt -le $maxRemoveAttempts; $removeAttempt++) {
+                    try {
+                        Remove-Item -Path $tempProfile -Recurse -Force -ErrorAction Stop
+                        WriteLog "Removed temporary Edge profile at $tempProfile."
+                        break
+                    }
+                    catch {
+                        if ($removeAttempt -eq $maxRemoveAttempts) {
+                            WriteLog "Failed to remove temporary Edge profile at $tempProfile after $maxRemoveAttempts attempts. Error: $($_.Exception.Message)"
+                        }
+                        else {
+                            WriteLog "Temporary Edge profile still locked (attempt $removeAttempt of $maxRemoveAttempts). Retrying..."
+                            Start-Sleep -Milliseconds 500
+                        }
+                    }
+                }
+            }
+            finally {
+                $ProgressPreference = $originalProgressPreference
+            }
         }
-    }
-    else {
-        WriteLog "No active Edge process found to terminate."
     }
 
     return $token
@@ -389,4 +815,8 @@ function Get-LenovoPSREFToken {
 # SECTION: Module Export
 # --------------------------------------------------------------------------
 
-Export-ModuleMember -Function Compress-DriverFolderToWim, Update-DriverMappingJson, Test-ExistingDriver, Get-LenovoPSREFToken
+Export-ModuleMember -Function `
+    Compress-DriverFolderToWim, `
+    Update-DriverMappingJson, `
+    Test-ExistingDriver, `
+    Get-LenovoPSREFToken

FFUDevelopment/FFU.Common/FFU.Common.Parallel.psm1

@@ -156,7 +156,7 @@ function Invoke-ParallelProcessing {
                 # Execute the appropriate background task based on $localTaskType
                 switch ($localTaskType) {
                     'WingetDownload' {
-                        # Pass the progress queue to the task function
+                        # Pass the progress queue and SkipWin32Json to the task function
                         $wingetTaskArgs = @{
                             ApplicationItemData = $currentItem
                             AppListJsonPath     = $localJobArgs['AppListJsonPath']
@@ -164,6 +164,7 @@ function Invoke-ParallelProcessing {
                             OrchestrationPath   = $localJobArgs['OrchestrationPath']
                             ProgressQueue       = $localProgressQueue
                             WindowsArch         = $localJobArgs['WindowsArch']
+                            SkipWin32Json       = [bool]$localJobArgs['SkipWin32Json']
                         }
                         $taskResult = Start-WingetAppDownloadTask @wingetTaskArgs
                         if ($null -ne $taskResult) {
@@ -209,7 +210,8 @@ function Invoke-ParallelProcessing {
                                     -Headers $localJobArgs['Headers'] `
                                     -UserAgent $localJobArgs['UserAgent'] `
                                     -ProgressQueue $localProgressQueue `
-                                    -CompressToWim $localJobArgs['CompressToWim']
+                                    -CompressToWim $localJobArgs['CompressToWim'] `
+                                    -PreserveSourceOnCompress $localJobArgs['PreserveSourceOnCompress']
                             }
                             'Dell' {
                                 $taskResult = Save-DellDriversTask -DriverItemData $currentItem `
@@ -217,7 +219,8 @@ function Invoke-ParallelProcessing {
                                     -WindowsArch $localJobArgs['WindowsArch'] `
                                     -WindowsRelease $localJobArgs['WindowsRelease'] `
                                     -ProgressQueue $localProgressQueue `
-                                    -CompressToWim $localJobArgs['CompressToWim']
+                                    -CompressToWim $localJobArgs['CompressToWim'] `
+                                    -PreserveSourceOnCompress $localJobArgs['PreserveSourceOnCompress']
                             }
                             'HP' {
                                 $taskResult = Save-HPDriversTask -DriverItemData $currentItem `
@@ -226,7 +229,8 @@ function Invoke-ParallelProcessing {
                                     -WindowsRelease $localJobArgs['WindowsRelease'] `
                                     -WindowsVersion $localJobArgs['WindowsVersion'] `
                                     -ProgressQueue $localProgressQueue `
-                                    -CompressToWim $localJobArgs['CompressToWim']
+                                    -CompressToWim $localJobArgs['CompressToWim'] `
+                                    -PreserveSourceOnCompress $localJobArgs['PreserveSourceOnCompress']
                             }
                             'Lenovo' {
                                 $taskResult = Save-LenovoDriversTask -DriverItemData $currentItem `
@@ -235,7 +239,8 @@ function Invoke-ParallelProcessing {
                                     -Headers $localJobArgs['Headers'] `
                                     -UserAgent $localJobArgs['UserAgent'] `
                                     -ProgressQueue $localProgressQueue `
-                                    -CompressToWim $localJobArgs['CompressToWim']
+                                    -CompressToWim $localJobArgs['CompressToWim'] `
+                                    -PreserveSourceOnCompress $localJobArgs['PreserveSourceOnCompress']
                             }
                             default {
                                 $unsupportedMakeMessage = "Error: Unsupported Make '$make' for driver download."
@@ -265,7 +270,7 @@ function Invoke-ParallelProcessing {
                             else {
                                 # Fallback for any task that *still* doesn't return 'Success'. This is now the exceptional case.
                                 WriteLog "Warning: Task for '$taskSpecificIdentifier' did not return a 'Success' property. Inferring from status: '$($taskResult.Status)'"
-                                if ($taskResult.Status -like 'Completed*' -or $taskResult.Status -like 'Already downloaded*') {
+                                if ($taskResult.Status -like 'Completed*' -or $taskResult.Status -like 'Already downloaded*' -or $taskResult.Status -like 'Compression successful*') {
                                     $resultCode = 0 # Treat as success
                                 }
                                 else {

FFUDevelopment/FFU.Common/FFU.Common.psd1

@@ -67,8 +67,11 @@ Description = 'Common functions shared between FFU Builder UI and the BuildFFUVM
 
 # Modules to import as nested modules of the module specified in RootModule/ModuleToProcess
 NestedModules = @('FFU.Common.Drivers.psm1', 
+               'FFU.Common.Drivers.Microsoft.psm1',
+               'FFU.Common.Drivers.Dell.psm1',
                'FFU.Common.Winget.psm1', 
-               'FFU.Common.Parallel.psm1')
+               'FFU.Common.Parallel.psm1',
+               'FFU.Common.Cleanup.psm1')
 
 # Functions to export from this module, for best performance, do not use wildcards and do not delete the entry, use an empty array if there are no functions to export.
 FunctionsToExport = '*'

FFUDevelopment/FFUUI.Core/FFUUI.Core.Applications.psm1

@@ -396,8 +396,8 @@ function Invoke-CopyBYOApps {
 
     try {
         # Ensure items are sorted by current priority before saving
-        # Exclude CopyStatus when saving and ensure Priority is an integer
-        $applications = $listView.Items | Sort-Object Priority | Select-Object @{N = 'Priority'; E = { [int]$_.Priority } }, Name, CommandLine, Arguments, Source
+        # Exclude CopyStatus when saving and ensure Priority is an integer; include AdditionalExitCodes and IgnoreNonZeroExitCodes for parity with Save-BYOApplicationList
+        $applications = $listView.Items | Sort-Object Priority | Select-Object @{N = 'Priority'; E = { [int]$_.Priority } }, Name, CommandLine, Arguments, Source, AdditionalExitCodes, IgnoreNonZeroExitCodes
         $applications | ConvertTo-Json -Depth 5 | Set-Content -Path $userAppListPath -Force -Encoding UTF8
         WriteLog "Successfully updated UserAppList.json with all applications from the UI."
     }

FFUDevelopment/FFUUI.Core/FFUUI.Core.Config.psm1

@@ -34,8 +34,10 @@ function Get-UIConfig {
         CopyDrivers                    = $State.Controls.chkCopyDrivers.IsChecked
         CopyOfficeConfigXML            = $State.Controls.chkCopyOfficeConfigXML.IsChecked
         CopyPEDrivers                  = $State.Controls.chkCopyPEDrivers.IsChecked
+        UseDriversAsPEDrivers          = $State.Controls.chkUseDriversAsPEDrivers.IsChecked
         CopyPPKG                       = $State.Controls.chkCopyPPKG.IsChecked
         CopyUnattend                   = $State.Controls.chkCopyUnattend.IsChecked
+        CopyAdditionalFFUFiles         = $State.Controls.chkCopyAdditionalFFUFiles.IsChecked
         CreateCaptureMedia             = $State.Controls.chkCreateCaptureMedia.IsChecked
         CreateDeploymentMedia          = $State.Controls.chkCreateDeploymentMedia.IsChecked
         InjectUnattend                 = $State.Controls.chkInjectUnattend.IsChecked
@@ -80,6 +82,7 @@ function Get-UIConfig {
         RemoveApps                     = $State.Controls.chkRemoveApps.IsChecked
         RemoveFFU                      = $State.Controls.chkRemoveFFU.IsChecked
         RemoveUpdates                  = $State.Controls.chkRemoveUpdates.IsChecked
+        RemoveDownloadedESD            = $State.Controls.chkRemoveDownloadedESD.IsChecked
         ShareName                      = $State.Controls.txtShareName.Text
         UpdateADK                      = $State.Controls.chkUpdateADK.IsChecked
         UpdateEdge                     = $State.Controls.chkUpdateEdge.IsChecked
@@ -94,6 +97,7 @@ function Get-UIConfig {
         USBDriveList                   = @{}
         Username                       = $State.Controls.txtUsername.Text
         Threads                        = [int]$State.Controls.txtThreads.Text
+        BitsPriority                    = $State.Controls.cmbBitsPriority.SelectedItem
         MaxUSBDrives                   = [int]$State.Controls.txtMaxUSBDrives.Text
         Verbose                        = $State.Controls.chkVerbose.IsChecked
         VMHostIPAddress                = $State.Controls.txtVMHostIPAddress.Text
@@ -111,8 +115,38 @@ function Get-UIConfig {
         WindowsVersion                 = $State.Controls.cmbWindowsVersion.SelectedItem
     }
 
+    # Save selected USB drives using UniqueId for reliable identification
+    # Multiple physical drives can share the same Model, so store an array of UniqueIds per Model.
     $State.Controls.lstUSBDrives.Items | Where-Object { $_.IsSelected } | ForEach-Object {
-        $config.USBDriveList[$_.Model] = $_.SerialNumber
+        $modelName = $_.Model
+        $uniqueId = $_.UniqueId
+
+        if ([string]::IsNullOrWhiteSpace($modelName) -or [string]::IsNullOrWhiteSpace($uniqueId)) {
+            return
+        }
+
+        # Ensure the hashtable value is always an array so multiple same-model drives are preserved
+        $existingUniqueIds = $config.USBDriveList[$modelName]
+        if ($null -eq $existingUniqueIds) {
+            $config.USBDriveList[$modelName] = @($uniqueId)
+            return
+        }
+
+        $existingUniqueIds = @($existingUniqueIds)
+        if (-not ($existingUniqueIds -contains $uniqueId)) {
+            $existingUniqueIds += $uniqueId
+        }
+        $config.USBDriveList[$modelName] = $existingUniqueIds
+    }
+
+    # Additional FFU file selections
+    $config.AdditionalFFUFiles = @()
+    if ($State.Controls.chkCopyAdditionalFFUFiles.IsChecked) {
+        $config.AdditionalFFUFiles = @(
+            $State.Controls.lstAdditionalFFUs.Items |
+                Where-Object { $_.IsSelected } |
+                ForEach-Object { $_.FullName }
+        )
     }
     
     return $config
@@ -231,6 +265,55 @@ function Set-UIValue {
     }
 }
 
+function Get-ConfigDriverBaseName {
+    param(
+        [string]$RawName
+    )
+
+    if ([string]::IsNullOrWhiteSpace($RawName)) {
+        return $RawName
+    }
+
+    if ($RawName -match '^(.*?)\s*\((.+)\)\s*$') {
+        return $matches[1].Trim()
+    }
+
+    return $RawName.Trim()
+}
+
+function Get-ConfigDriverDisplayName {
+    param(
+        [string]$Make,
+        [string]$StoredName,
+        [string]$ProductName,
+        [string]$SystemId,
+        [string]$MachineType
+    )
+
+    $baseName = if (-not [string]::IsNullOrWhiteSpace($ProductName)) { $ProductName } else { Get-ConfigDriverBaseName -RawName $StoredName }
+
+    switch ($Make) {
+        'Dell' {
+            if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $StoredName }
+            if ([string]::IsNullOrWhiteSpace($SystemId)) { return $baseName }
+            return "{0} ({1})" -f $baseName.Trim(), $SystemId.Trim()
+        }
+        'HP' {
+            if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $StoredName }
+            if ([string]::IsNullOrWhiteSpace($SystemId)) { return $baseName }
+            return "{0} ({1})" -f $baseName.Trim(), $SystemId.Trim()
+        }
+        'Lenovo' {
+            if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $StoredName }
+            if ([string]::IsNullOrWhiteSpace($MachineType)) { return $baseName }
+            return "{0} ({1})" -f $baseName.Trim(), $MachineType.Trim()
+        }
+        default {
+            return $StoredName
+        }
+    }
+}
+
 function Invoke-LoadConfiguration {
     param(
         [Parameter(Mandatory = $true)]
@@ -242,19 +325,39 @@ function Invoke-LoadConfiguration {
             WriteLog "Load configuration cancelled by user."
             return
         }
-
         WriteLog "Loading configuration from: $filePath"
-        $configContent = Get-Content -Path $filePath -Raw | ConvertFrom-Json
-
+        $raw = $null
+        try {
+            $raw = Get-Content -Path $filePath -Raw -ErrorAction Stop
+        }
+        catch {
+            WriteLog "LoadConfig Error: Failed reading file $filePath : $($_.Exception.Message)"
+            [System.Windows.MessageBox]::Show("Failed to read the configuration file.`n$($_.Exception.Message)", "Load Error", "OK", "Error")
+            return
+        }
+        if ([string]::IsNullOrWhiteSpace($raw)) {
+            WriteLog "LoadConfig Error: File $filePath is empty."
+            [System.Windows.MessageBox]::Show("The selected configuration file is empty.", "Load Error", "OK", "Error")
+            return
+        }
+        $configContent = $null
+        try {
+            $configContent = $raw | ConvertFrom-Json -ErrorAction Stop
+        }
+        catch {
+            WriteLog "LoadConfig Error: JSON parse failure for $filePath : $($_.Exception.Message)"
+            [System.Windows.MessageBox]::Show("Failed to parse the configuration file (invalid JSON).`n$($_.Exception.Message)", "Load Error", "OK", "Error")
+            return
+        }
         if ($null -eq $configContent) {
-            WriteLog "LoadConfig Error: configContent is null after parsing $filePath. File might be empty or malformed."
-            [System.Windows.MessageBox]::Show("Failed to parse the configuration file. It might be empty or not valid JSON.", "Load Error", "OK", "Error")
+            WriteLog "LoadConfig Error: Parsed config object is null after $filePath."
+            [System.Windows.MessageBox]::Show("Parsed configuration object was null.", "Load Error", "OK", "Error")
             return
         }
         WriteLog "LoadConfig: Successfully parsed config file. Top-level keys: $($configContent.PSObject.Properties.Name -join ', ')"
-
-        # Apply the configuration to the UI
         Update-UIFromConfig -ConfigContent $configContent -State $State
+        $State.Data.lastConfigFilePath = $filePath
+        Import-ConfigSupplementalAssets -ConfigContent $configContent -State $State -ShowWarnings:$true
     }
     catch {
         WriteLog "LoadConfig FATAL Error: $($_.Exception.ToString())"
@@ -331,6 +434,7 @@ function Update-UIFromConfig {
     Set-UIValue -ControlName 'txtShareName' -PropertyName 'Text' -ConfigObject $ConfigContent -ConfigKey 'ShareName' -State $State
     Set-UIValue -ControlName 'txtUsername' -PropertyName 'Text' -ConfigObject $ConfigContent -ConfigKey 'Username' -State $State
     Set-UIValue -ControlName 'txtThreads' -PropertyName 'Text' -ConfigObject $ConfigContent -ConfigKey 'Threads' -State $State
+    Set-UIValue -ControlName 'cmbBitsPriority' -PropertyName 'SelectedItem' -ConfigObject $ConfigContent -ConfigKey 'BitsPriority' -State $State
     Set-UIValue -ControlName 'txtMaxUSBDrives' -PropertyName 'Text' -ConfigObject $ConfigContent -ConfigKey 'MaxUSBDrives' -State $State
     Set-UIValue -ControlName 'chkBuildUSBDriveEnable' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'BuildUSBDrive' -State $State
     Set-UIValue -ControlName 'chkCompactOS' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'CompactOS' -State $State
@@ -339,6 +443,7 @@ function Update-UIFromConfig {
     Set-UIValue -ControlName 'chkAllowVHDXCaching' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'AllowVHDXCaching' -State $State
     Set-UIValue -ControlName 'chkAllowExternalHardDiskMedia' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'AllowExternalHardDiskMedia' -State $State
     Set-UIValue -ControlName 'chkPromptExternalHardDiskMedia' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'PromptExternalHardDiskMedia' -State $State
+    Set-UIValue -ControlName 'chkCopyAdditionalFFUFiles' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'CopyAdditionalFFUFiles' -State $State
     Set-UIValue -ControlName 'chkCreateCaptureMedia' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'CreateCaptureMedia' -State $State
     Set-UIValue -ControlName 'chkCreateDeploymentMedia' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'CreateDeploymentMedia' -State $State
     Set-UIValue -ControlName 'chkInjectUnattend' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'InjectUnattend' -State $State
@@ -357,6 +462,7 @@ function Update-UIFromConfig {
     Set-UIValue -ControlName 'chkRemoveFFU' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'RemoveFFU' -State $State
     Set-UIValue -ControlName 'chkRemoveApps' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'RemoveApps' -State $State
     Set-UIValue -ControlName 'chkRemoveUpdates' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'RemoveUpdates' -State $State
+    Set-UIValue -ControlName 'chkRemoveDownloadedESD' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'RemoveDownloadedESD' -State $State
 
     # Hyper-V Settings
     Select-VMSwitchFromConfig -State $State -ConfigContent $ConfigContent
@@ -460,6 +566,7 @@ function Update-UIFromConfig {
     Set-UIValue -ControlName 'txtPEDriversFolder' -PropertyName 'Text' -ConfigObject $ConfigContent -ConfigKey 'PEDriversFolder' -State $State
     Set-UIValue -ControlName 'txtDriversJsonPath' -PropertyName 'Text' -ConfigObject $ConfigContent -ConfigKey 'DriversJsonPath' -State $State
     Set-UIValue -ControlName 'chkCopyPEDrivers' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'CopyPEDrivers' -State $State
+    Set-UIValue -ControlName 'chkUseDriversAsPEDrivers' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'UseDriversAsPEDrivers' -State $State
     Set-UIValue -ControlName 'chkCompressDriversToWIM' -PropertyName 'IsChecked' -ConfigObject $ConfigContent -ConfigKey 'CompressDownloadedDriversToWim' -State $State
 
     # Updates tab
@@ -584,8 +691,21 @@ function Update-UIFromConfig {
                 }
             }
 
-            if ($propertyExists -and ($propertyValue -eq $item.SerialNumber)) {
-                WriteLog "LoadConfig: Selecting USB Drive Model '$($item.Model)' with Serial '$($item.SerialNumber)'."
+            # Match USB drives by UniqueId instead of SerialNumber
+            # USBDriveList values can be a single UniqueId (string) or an array of UniqueIds (multiple same-model drives)
+            $isMatch = $false
+            if ($propertyExists) {
+                if ($propertyValue -is [string]) {
+                    $isMatch = ($propertyValue -eq $item.UniqueId)
+                }
+                else {
+                    $propertyValueArray = @($propertyValue)
+                    $isMatch = ($propertyValueArray -contains $item.UniqueId)
+                }
+            }
+
+            if ($isMatch) {
+                WriteLog "LoadConfig: Selecting USB Drive Model '$($item.Model)' with UniqueId '$($item.UniqueId)'."
                 $item.IsSelected = $true
             }
             else {
@@ -632,8 +752,47 @@ function Update-UIFromConfig {
     else {
         WriteLog "LoadConfig: Condition to auto-check 'Select Specific USB Drives' was NOT met."
     }
-    WriteLog "LoadConfig: Configuration loading process finished."
-}
+        # Populate additional FFU list and apply selections
+        try {
+            if ($State.Controls.chkCopyAdditionalFFUFiles.IsChecked) {
+                $State.Controls.additionalFFUPanel.Visibility = 'Visible'
+                if ($State.Controls.btnRefreshAdditionalFFUs) {
+                    $State.Controls.btnRefreshAdditionalFFUs.RaiseEvent([System.Windows.RoutedEventArgs]::new([System.Windows.Controls.Button]::ClickEvent))
+                }
+                $selectedFiles = @()
+                $addFFUKeyExists = $false
+                if ($ConfigContent -is [System.Management.Automation.PSCustomObject] -and $null -ne $ConfigContent.PSObject.Properties) {
+                    if (($ConfigContent.PSObject.Properties.Match('AdditionalFFUFiles')).Count -gt 0) {
+                        $addFFUKeyExists = $true
+                    }
+                }
+                if ($addFFUKeyExists -and $null -ne $ConfigContent.AdditionalFFUFiles) {
+                    $selectedFiles = @($ConfigContent.AdditionalFFUFiles)
+                }
+                if ($selectedFiles.Count -gt 0) {
+                    foreach ($item in $State.Controls.lstAdditionalFFUs.Items) {
+                        if ($selectedFiles -contains $item.FullName) {
+                            $item.IsSelected = $true
+                        }
+                    }
+                    $State.Controls.lstAdditionalFFUs.Items.Refresh()
+                    $headerChk = $State.Controls.chkSelectAllAdditionalFFUs
+                    if ($null -ne $headerChk) {
+                        Update-SelectAllHeaderCheckBoxState -ListView $State.Controls.lstAdditionalFFUs -HeaderCheckBox $headerChk
+                    }
+                }
+            }
+            else {
+                $State.Controls.additionalFFUPanel.Visibility = 'Collapsed'
+            }
+            }
+            catch {
+                WriteLog "LoadConfig: Error applying Additional FFU selections: $($_.Exception.Message)"
+            }
+        
+            Update-BitsPrioritySetting -State $State
+            WriteLog "LoadConfig: Configuration loading process finished."
+        }
 
 function Invoke-SaveConfiguration {
     param(
@@ -655,7 +814,10 @@ function Invoke-SaveConfiguration {
             -DefaultExt ".json"
 
         if ($savePath) {
-            $config | ConvertTo-Json -Depth 10 | Set-Content -Path $savePath -Encoding UTF8
+            # Sort top-level keys alphabetically for consistent output
+            $sortedConfig = [ordered]@{}
+            foreach ($k in ($config.Keys | Sort-Object)) { $sortedConfig[$k] = $config[$k] }
+            $sortedConfig | ConvertTo-Json -Depth 10 | Set-Content -Path $savePath -Encoding UTF8
             [System.Windows.MessageBox]::Show("Configuration file saved to:`n$savePath", "Success", "OK", "Information")
         }
     }
@@ -664,4 +826,435 @@ function Invoke-SaveConfiguration {
     }
 }
 
+function Invoke-RestoreDefaults {
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject]$State
+    )
+    try {
+        $rootPath = $State.FFUDevelopmentPath
+
+        # Normalize potential array values to single strings
+        function Normalize-PathScalar {
+            param([object]$value)
+            if ($null -eq $value) { return $null }
+            if ($value -is [System.Array]) {
+                foreach ($v in $value) {
+                    if (-not [string]::IsNullOrWhiteSpace([string]$v)) {
+                        return [string]$v
+                    }
+                }
+                return $null
+            }
+            return [string]$value
+        }
+
+        $appsPath = Join-Path $rootPath 'Apps'
+        $driversRaw = Normalize-PathScalar -value $State.Controls.txtDriversFolder.Text
+        if ([string]::IsNullOrWhiteSpace($driversRaw)) {
+            $driversPath = Join-Path $rootPath 'Drivers'
+        }
+        else {
+            $driversPath = $driversRaw
+        }
+        $ffuCaptureRaw = Normalize-PathScalar -value $State.Controls.txtFFUCaptureLocation.Text
+        $ffuCapturePath = if ([string]::IsNullOrWhiteSpace($ffuCaptureRaw)) { Join-Path $rootPath 'FFU' } else { $ffuCaptureRaw }
+
+        $captureISOPath = Join-Path $rootPath 'WinPECaptureFFUFiles\WinPE-Capture.iso'
+        $deployISOPath = Join-Path $rootPath 'WinPEDeployFFUFiles\WinPE-Deploy.iso'
+        $appsISOPath = Join-Path $rootPath 'Apps.iso'
+        
+        $msg = "Restore Defaults will:`n`n- Delete generated config and app/driver list JSON files`n- Remove ISO files (Capture, Deploy, Apps) if present`n- Remove Apps/Update/downloaded artifacts`n- Remove driver folder contents (not the folder)`n- Remove FFU files in the capture folder`n`nSample/template files and VM/VHDX cache are NOT removed.`n`nProceed?"
+        $result = [System.Windows.MessageBox]::Show($msg, "Confirm Restore Defaults", "YesNo", "Warning")
+        if ($result -ne [System.Windows.MessageBoxResult]::Yes) {
+            WriteLog "RestoreDefaults: User cancelled."
+            return
+        }
+
+        WriteLog "RestoreDefaults: Starting environment reset."
+        WriteLog "RestoreDefaults: Paths -> Apps=$appsPath Drivers=$driversPath FFUCapture=$ffuCapturePath"
+
+        # Remove JSON artifact files if present
+        $artifactFiles = @(
+            (Join-Path $rootPath 'config\FFUConfig.json'),
+            (Join-Path $appsPath 'AppList.json'),
+            (Join-Path $driversPath 'Drivers.json'),
+            (Join-Path $appsPath 'UserAppList.json')
+        ) | Where-Object { -not [string]::IsNullOrWhiteSpace($_) }
+
+        foreach ($file in $artifactFiles) {
+            if ((-not [string]::IsNullOrWhiteSpace($file)) -and (Test-Path -LiteralPath $file)) {
+                try {
+                    WriteLog "RestoreDefaults: Removing $file"
+                    Remove-Item -LiteralPath $file -Force -ErrorAction Stop
+                }
+                catch {
+                    WriteLog "RestoreDefaults: Failed removing $file : $($_.Exception.Message)"
+                }
+            }
+        }
+
+        # Force all cleanup flags true
+        Invoke-FFUPostBuildCleanup `
+            -RootPath $rootPath `
+            -AppsPath $appsPath `
+            -DriversPath $driversPath `
+            -FFUCapturePath $ffuCapturePath `
+            -CaptureISOPath $captureISOPath `
+            -DeployISOPath $deployISOPath `
+            -AppsISOPath $appsISOPath `
+            -KBPath (Join-Path $rootPath 'KB') `
+            -RemoveCaptureISO:$true `
+            -RemoveDeployISO:$true `
+            -RemoveAppsISO:$true `
+            -RemoveDrivers:$true `
+            -RemoveFFU:$true `
+            -RemoveApps:$true `
+            -RemoveUpdates:$true `
+            -RemoveDownloadedESD:$true
+
+        # Clear UI lists / state
+        if ($null -ne $State.Data.allDriverModels) { $State.Data.allDriverModels.Clear() }
+        if ($null -ne $State.Controls.lstDriverModels) { $State.Controls.lstDriverModels.Items.Refresh() }
+        if ($null -ne $State.Controls.lstApplications) {
+            try {
+                if ($State.Controls.lstApplications.ItemsSource) { $State.Controls.lstApplications.ItemsSource = $null }
+                $State.Controls.lstApplications.Items.Clear()
+            } catch {}
+        }
+        if ($null -ne $State.Controls.lstWingetResults) {
+            try { 
+                if ($State.Controls.lstWingetResults.ItemsSource) { $State.Controls.lstWingetResults.ItemsSource = $null }
+                $State.Controls.lstWingetResults.Items.Clear() 
+            } catch {}
+        }
+        if ($null -ne $State.Controls.lstAppsScriptVariables) {
+            try {
+                if ($State.Controls.lstAppsScriptVariables.ItemsSource) { $State.Controls.lstAppsScriptVariables.ItemsSource = $null }
+                $State.Controls.lstAppsScriptVariables.Items.Clear()
+            } catch {}
+        }
+
+        $State.Data.lastConfigFilePath = $null
+
+        Initialize-UIDefaults -State $State
+
+        WriteLog "RestoreDefaults: Completed."
+        [System.Windows.MessageBox]::Show("Environment restored to defaults.", "Restore Defaults", "OK", "Information")
+    }
+    catch {
+        WriteLog "RestoreDefaults: Failed with $($_.Exception.Message)"
+        [System.Windows.MessageBox]::Show("Restore Defaults failed:`n$($_.Exception.Message)", "Error", "OK", "Error")
+    }
+}
+
+function Invoke-AutoLoadPreviousEnvironment {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject]$State
+    )
+    try {
+        $ffuDevRoot = $State.FFUDevelopmentPath
+        if ([string]::IsNullOrWhiteSpace($ffuDevRoot)) {
+            WriteLog "AutoLoad: FFUDevelopmentPath not set; skipping."
+            return
+        }
+        $configPath = Join-Path $ffuDevRoot "config\FFUConfig.json"
+        if (-not (Test-Path -LiteralPath $configPath)) {
+            WriteLog "AutoLoad: No existing FFUConfig.json found at $configPath."
+            return
+        }
+        WriteLog "AutoLoad: Found config file at $configPath. Parsing..."
+        $raw = Get-Content -Path $configPath -Raw -ErrorAction SilentlyContinue
+        if ([string]::IsNullOrWhiteSpace($raw)) {
+            WriteLog "AutoLoad: Config file empty; aborting."
+            return
+        }
+        $configContent = $null
+        try {
+            $configContent = $raw | ConvertFrom-Json -ErrorAction Stop
+        }
+        catch {
+            WriteLog "AutoLoad: JSON parse failed: $($_.Exception.Message)"
+            return
+        }
+        if ($null -eq $configContent) {
+            WriteLog "AutoLoad: Parsed object null; aborting."
+            return
+        }
+        WriteLog "AutoLoad: Applying core configuration."
+        Update-UIFromConfig -ConfigContent $configContent -State $State
+        $State.Data.lastConfigFilePath = $configPath
+        Import-ConfigSupplementalAssets -ConfigContent $configContent -State $State -ShowWarnings:$false
+        WriteLog "AutoLoad: Completed supplemental import with warnings disabled."
+    }
+    catch {
+        WriteLog "AutoLoad: Unexpected failure: $($_.Exception.ToString())"
+    }
+}
+
+function Import-ConfigSupplementalAssets {
+    param(
+        [Parameter(Mandatory = $true)]
+        [psobject]$ConfigContent,
+        [Parameter(Mandatory = $true)]
+        [psobject]$State,
+        [Parameter()]
+        [bool]$ShowWarnings = $false
+    )
+    WriteLog "SupplementalImport: Starting import of helper assets."
+    $loadedWinget = $false
+    $loadedBYO = $false
+    $loadedDrivers = $false
+    $missing = New-Object System.Collections.Generic.List[string]
+
+    # Winget AppList
+    $appListPath = $null
+    if ($ConfigContent.PSObject.Properties.Match('AppListPath').Count -gt 0) {
+        $appListPath = $ConfigContent.AppListPath
+    }
+    if (-not [string]::IsNullOrWhiteSpace($appListPath)) {
+        if (Test-Path -LiteralPath $appListPath) {
+            WriteLog "SupplementalImport: Loading Winget AppList from $appListPath"
+            try {
+                $importedAppsData = Get-Content -Path $appListPath -Raw | ConvertFrom-Json -ErrorAction Stop
+                if ($null -ne $importedAppsData -and $null -ne $importedAppsData.apps) {
+                    $defaultArch = $State.Controls.cmbWindowsArch.SelectedItem
+                    $appsBuffer = [System.Collections.Generic.List[object]]::new()
+                    foreach ($appInfo in $importedAppsData.apps) {
+                        $arch = if ($appInfo.source -eq 'msstore') { 'NA' } else {
+                            if ($appInfo.PSObject.Properties['architecture']) { $appInfo.architecture } else { $defaultArch }
+                        }
+                        $appsBuffer.Add([PSCustomObject]@{
+                                IsSelected               = $true
+                                Name                     = $appInfo.name
+                                Id                       = $appInfo.id
+                                Version                  = ""
+                                Source                   = $appInfo.source
+                                Architecture             = $arch
+                                AdditionalExitCodes      = if ($appInfo.PSObject.Properties['AdditionalExitCodes']) { $appInfo.AdditionalExitCodes } else { "" }
+                                IgnoreNonZeroExitCodes   = if ($appInfo.PSObject.Properties['IgnoreNonZeroExitCodes']) { [bool]$appInfo.IgnoreNonZeroExitCodes } else { $false }
+                                DownloadStatus           = ""
+                            })
+                    }
+                    $State.Controls.lstWingetResults.ItemsSource = $appsBuffer.ToArray()
+                    $loadedWinget = $true
+                    if ($null -ne $State.Controls.wingetSearchPanel) {
+                        $State.Controls.wingetSearchPanel.Visibility = 'Visible'
+                    }
+                    if ($null -ne $State.Controls.chkSelectAllWingetResults -and (Get-Command -Name Update-SelectAllHeaderCheckBoxState -ErrorAction SilentlyContinue)) {
+                        Update-SelectAllHeaderCheckBoxState -ListView $State.Controls.lstWingetResults -HeaderCheckBox $State.Controls.chkSelectAllWingetResults
+                    }
+                    WriteLog "SupplementalImport: Winget list loaded with $($appsBuffer.Count) entries."
+                }
+                else {
+                    WriteLog "SupplementalImport: Winget AppList missing 'apps' array."
+                }
+            }
+            catch {
+                WriteLog "SupplementalImport: Failed loading Winget AppList ($appListPath): $($_.Exception.Message)"
+            }
+        }
+        else {
+            WriteLog "SupplementalImport: Winget AppList file missing: $appListPath"
+            $missing.Add("Winget AppList (AppListPath): $appListPath")
+        }
+    }
+    else {
+        WriteLog "SupplementalImport: AppListPath not defined in config."
+    }
+
+    # UserAppList (BYO)
+    $userAppListPath = $null
+    if ($ConfigContent.PSObject.Properties.Match('UserAppListPath').Count -gt 0) {
+        $userAppListPath = $ConfigContent.UserAppListPath
+    }
+    if (-not [string]::IsNullOrWhiteSpace($userAppListPath)) {
+        if (Test-Path -LiteralPath $userAppListPath) {
+            WriteLog "SupplementalImport: Loading UserAppList from $userAppListPath"
+            try {
+                $applications = Get-Content -Path $userAppListPath -Raw | ConvertFrom-Json -ErrorAction Stop
+                if ($applications) {
+                    $listView = $State.Controls.lstApplications
+                    $listView.Items.Clear()
+                    $sortedApps = $applications | Sort-Object Priority
+                    foreach ($app in $sortedApps) {
+                        $ignoreNonZero = if ($app.PSObject.Properties['IgnoreNonZeroExitCodes']) { $app.IgnoreNonZeroExitCodes } else { $false }
+                        $listView.Items.Add([PSCustomObject]@{
+                                IsSelected             = $false
+                                Priority               = $app.Priority
+                                Name                   = $app.Name
+                                CommandLine            = $app.CommandLine
+                                Arguments              = if ($app.PSObject.Properties['Arguments']) { $app.Arguments } else { "" }
+                                Source                 = $app.Source
+                                AdditionalExitCodes    = if ($app.PSObject.Properties['AdditionalExitCodes']) { $app.AdditionalExitCodes } else { "" }
+                                IgnoreNonZeroExitCodes = $ignoreNonZero
+                                IgnoreExitCodes        = if ($ignoreNonZero) { "Yes" } else { "No" }
+                                CopyStatus             = ""
+                            })
+                    }
+                    if (Get-Command -Name Update-ListViewPriorities -ErrorAction SilentlyContinue) {
+                        Update-ListViewPriorities -ListView $listView
+                    }
+                    if (Get-Command -Name Update-CopyButtonState -ErrorAction SilentlyContinue) {
+                        Update-CopyButtonState -State $State
+                    }
+                    if (Get-Command -Name Update-BYOAppsActionButtonsState -ErrorAction SilentlyContinue) {
+                        Update-BYOAppsActionButtonsState -State $State
+                    }
+                    $loadedBYO = $true
+                    WriteLog "SupplementalImport: UserAppList loaded with $($listView.Items.Count) entries."
+                }
+                else {
+                    WriteLog "SupplementalImport: UserAppList JSON empty."
+                }
+            }
+            catch {
+                WriteLog "SupplementalImport: Failed loading UserAppList ($userAppListPath): $($_.Exception.Message)"
+            }
+        }
+        else {
+            WriteLog "SupplementalImport: UserAppList file missing: $userAppListPath"
+            $missing.Add("UserAppList (UserAppListPath): $userAppListPath")
+        }
+    }
+    else {
+        WriteLog "SupplementalImport: UserAppListPath not defined in config."
+    }
+
+    # Drivers JSON
+    $driversJsonPath = $null
+    if ($ConfigContent.PSObject.Properties.Match('DriversJsonPath').Count -gt 0) {
+        $driversJsonPath = $ConfigContent.DriversJsonPath
+    }
+    if (-not [string]::IsNullOrWhiteSpace($driversJsonPath)) {
+        if (Test-Path -LiteralPath $driversJsonPath) {
+            WriteLog "SupplementalImport: Loading Drivers JSON from $driversJsonPath"
+            try {
+                $rawDrivers = Get-Content -Path $driversJsonPath -Raw | ConvertFrom-Json -ErrorAction Stop
+                if ($rawDrivers -and $rawDrivers.PSObject.Properties.Count -gt 0) {
+                    $State.Data.allDriverModels.Clear()
+                    foreach ($makeProp in $rawDrivers.PSObject.Properties) {
+                        $makeName = $makeProp.Name
+                        $makeObject = $makeProp.Value
+                        if ($null -eq $makeObject -or -not ($makeObject.PSObject.Properties['Models'])) { continue }
+                        $models = $makeObject.Models
+                        if ($models -and ($models -is [System.Collections.IEnumerable])) {
+                            foreach ($modelEntry in $models) {
+                                if ($null -eq $modelEntry -or -not ($modelEntry.PSObject.Properties['Name'])) { continue }
+                                $modelName = $modelEntry.Name
+                                if ([string]::IsNullOrWhiteSpace($modelName)) { continue }
+                                $downloadStatus = if ($modelEntry.PSObject.Properties['DownloadStatus']) { $modelEntry.DownloadStatus } else { "" }
+                                $linkValue = if ($modelEntry.PSObject.Properties['Link']) { $modelEntry.Link } else { $null }
+                                $productName = if ($modelEntry.PSObject.Properties['ProductName']) { $modelEntry.ProductName } else { $null }
+                                $machineType = if ($modelEntry.PSObject.Properties['MachineType']) { $modelEntry.MachineType } else { $null }
+                                $systemId = if ($modelEntry.PSObject.Properties['SystemId']) { $modelEntry.SystemId } else { $null }
+                                $idValue = if ($modelEntry.PSObject.Properties['Id']) { $modelEntry.Id } else { $null }
+                                if ($null -eq $idValue -and -not [string]::IsNullOrWhiteSpace($systemId)) { $idValue = $systemId }
+                                if ($null -eq $idValue -and -not [string]::IsNullOrWhiteSpace($machineType)) { $idValue = $machineType }
+                                $displayModel = Get-ConfigDriverDisplayName -Make $makeName -StoredName $modelName -ProductName $productName -SystemId $systemId -MachineType $machineType
+                                if ([string]::IsNullOrWhiteSpace($displayModel)) {
+                                    $displayModel = $modelName
+                                }
+                                $driverObj = [PSCustomObject]@{
+                                    IsSelected     = $true
+                                    Make           = $makeName
+                                    Model          = $displayModel
+                                    DownloadStatus = $downloadStatus
+                                    Link           = $linkValue
+                                    ProductName    = $productName
+                                    MachineType    = $machineType
+                                    SystemId       = $systemId
+                                    Id             = $idValue
+                                }
+                                $State.Data.allDriverModels.Add($driverObj)
+                            }
+                        }
+                    }
+                    $State.Controls.lstDriverModels.ItemsSource = $State.Data.allDriverModels
+                    if (Get-Command -Name Update-SelectAllHeaderCheckBoxState -ErrorAction SilentlyContinue) {
+                        $headerChk = $State.Controls.chkSelectAllDriverModels
+                        if ($null -ne $headerChk) {
+                            Update-SelectAllHeaderCheckBoxState -ListView $State.Controls.lstDriverModels -HeaderCheckBox $headerChk
+                        }
+                    }
+                    if ($State.Data.allDriverModels.Count -gt 0) {
+                        if ($null -ne $State.Controls.spModelFilterSection) { $State.Controls.spModelFilterSection.Visibility = 'Visible' }
+                        if ($null -ne $State.Controls.lstDriverModels) { $State.Controls.lstDriverModels.Visibility = 'Visible' }
+                        if ($null -ne $State.Controls.spDriverActionButtons) { $State.Controls.spDriverActionButtons.Visibility = 'Visible' }
+                        try {
+                            if ($State.Controls.cmbMake.SelectedIndex -lt 0 -and $State.Data.allDriverModels.Count -gt 0) {
+                                $firstMake = ($State.Data.allDriverModels | Select-Object -First 1).Make
+                                if (-not [string]::IsNullOrWhiteSpace($firstMake)) {
+                                    $makeItem = $State.Controls.cmbMake.Items | Where-Object { $_ -eq $firstMake } | Select-Object -First 1
+                                    if ($makeItem) { $State.Controls.cmbMake.SelectedItem = $makeItem }
+                                }
+                            }
+                        }
+                        catch {
+                            WriteLog "SupplementalImport: Non-fatal error selecting first Make: $($_.Exception.Message)"
+                        }
+                    }
+                    $loadedDrivers = $true
+                    WriteLog "SupplementalImport: Loaded $($State.Data.allDriverModels.Count) driver models."
+                }
+                else {
+                    WriteLog "SupplementalImport: Drivers JSON empty or structure unexpected."
+                }
+            }
+            catch {
+                WriteLog "SupplementalImport: Failed loading Drivers JSON ($driversJsonPath): $($_.Exception.Message)"
+            }
+        }
+        else {
+            WriteLog "SupplementalImport: Drivers JSON file missing: $driversJsonPath"
+            $missing.Add("Drivers (DriversJsonPath): $driversJsonPath")
+        }
+    }
+    else {
+        WriteLog "SupplementalImport: DriversJsonPath not defined in config."
+    }
+
+    if ($loadedWinget -or $loadedBYO) {
+        $State.Controls.chkInstallApps.IsChecked = $true
+    }
+    if ($loadedWinget) {
+        $State.Controls.chkInstallWingetApps.IsChecked = $true
+    }
+    if ($loadedBYO) {
+        $State.Controls.chkBringYourOwnApps.IsChecked = $true
+    }
+    if ($loadedDrivers) {
+        $State.Controls.chkDownloadDrivers.IsChecked = $true
+    }
+
+    if (Get-Command -Name Update-ApplicationPanelVisibility -ErrorAction SilentlyContinue) {
+        Update-ApplicationPanelVisibility -State $State -TriggeringControlName 'SupplementalImport'
+    }
+    if (Get-Command -Name Update-DriverDownloadPanelVisibility -ErrorAction SilentlyContinue) {
+        Update-DriverDownloadPanelVisibility -State $State
+    }
+    if (Get-Command -Name Update-DriverCheckboxStates -ErrorAction SilentlyContinue) {
+        Update-DriverCheckboxStates -State $State
+    }
+    if (Get-Command -Name Update-OfficePanelVisibility -ErrorAction SilentlyContinue) {
+        Update-OfficePanelVisibility -State $State
+    }
+    if (Get-Command -Name Update-CopyButtonState -ErrorAction SilentlyContinue) {
+        Update-CopyButtonState -State $State
+    }
+
+    # Updated message to clarify successful load and that missing helper files are optional if not yet created.
+    if ($ShowWarnings -and $missing.Count -gt 0) {
+        $msg = "Configuration file loaded successfully.`n`n" +
+            "Optional helper file(s) referenced in the configuration were not found:`n" +
+            ($missing | ForEach-Object { "- $_" } | Out-String) +
+            "`nThese files are optional. They won't exist until you create Winget (AppList.json), User (UserAppList.json), or Driver (Drivers.json) manifests. You can create them later or ignore this message."
+        [System.Windows.MessageBox]::Show($msg.TrimEnd(), "Configuration Loaded - Optional Files Missing", "OK", "Information") | Out-Null
+    }
+
+    WriteLog ("SupplementalImport: Complete. Winget={0} BYO={1} Drivers={2} Missing={3}" -f $loadedWinget, $loadedBYO, $loadedDrivers, $missing.Count)
+}
+
 Export-ModuleMember -Function *

FFUDevelopment/FFUUI.Core/FFUUI.Core.Drivers.Dell.psm1

@@ -12,147 +12,98 @@ function Get-DellDriversModelList {
         [Parameter(Mandatory = $true)]
         [int]$WindowsRelease,
         [Parameter(Mandatory = $true)]
-        [string]$DriversFolder, # Base drivers folder (e.g., C:\FFUDevelopment\Drivers)
+        [string]$DriversFolder,
         [Parameter(Mandatory = $true)]
-        [string]$Make # Should be 'Dell'
+        [string]$Make
     )
 
-    # Define Dell specific drivers folder and catalog file names
+    # Client pathway (<=11) uses CatalogIndexPC to build full Brand Model (SystemID) strings.
+    if ($WindowsRelease -le 11) {
+        $dellModels = Get-DellClientModels -CatalogIndexXmlPath (Get-DellCatalogIndex -DriversFolder $DriversFolder)
+        $final = [System.Collections.Generic.List[pscustomobject]]::new()
+        foreach ($m in $dellModels) {
+            $final.Add([pscustomobject]@{
+                    Make            = $Make
+                    Model           = $m.ModelDisplay
+                    Brand           = $m.Brand
+                    ModelNumber     = $m.ModelNumber
+                    SystemId        = $m.SystemId
+                    CabRelativePath = $m.CabRelativePath
+                    CabUrl          = $m.CabUrl
+                })
+        }
+        return $final
+    }
+
+    # Server pathway (unchanged – still uses Catalog.cab)
     $dellDriversFolder = Join-Path -Path $DriversFolder -ChildPath "Dell"
-    $catalogBaseName = if ($WindowsRelease -le 11) { "CatalogPC" } else { "Catalog" }
+    $catalogBaseName = "Catalog"
     $dellCabFile = Join-Path -Path $dellDriversFolder -ChildPath "$($catalogBaseName).cab"
     $dellCatalogXML = Join-Path -Path $dellDriversFolder -ChildPath "$($catalogBaseName).xml"
-    $catalogUrl = if ($WindowsRelease -le 11) { "http://downloads.dell.com/catalog/CatalogPC.cab" } else { "https://downloads.dell.com/catalog/Catalog.cab" }
+    $catalogUrl = "https://downloads.dell.com/catalog/Catalog.cab"
 
-    $uniqueModelNames = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
-    $reader = $null 
+    if (-not (Test-Path -Path $dellDriversFolder)) {
+        New-Item -Path $dellDriversFolder -ItemType Directory -Force | Out-Null
+    }
 
+    $download = $true
+    if (Test-Path -Path $dellCatalogXML) {
+        if (((Get-Date) - (Get-Item $dellCatalogXML).CreationTime).TotalDays -lt 7) {
+            $download = $false
+        }
+    }
+
+    if ($download) {
+        if (Test-Path $dellCabFile) { Remove-Item $dellCabFile -Force -ErrorAction SilentlyContinue }
+        if (Test-Path $dellCatalogXML) { Remove-Item $dellCatalogXML -Force -ErrorAction SilentlyContinue }
+        Start-BitsTransferWithRetry -Source $catalogUrl -Destination $dellCabFile
+        Invoke-Process -FilePath Expand.exe -ArgumentList """$dellCabFile"" ""$dellCatalogXML""" | Out-Null
+        Remove-Item $dellCabFile -Force -ErrorAction SilentlyContinue
+    }
+
+    if (-not (Test-Path $dellCatalogXML)) { throw "Dell server catalog XML missing: $dellCatalogXML" }
+
+    $settings = New-Object System.Xml.XmlReaderSettings
+    $settings.IgnoreWhitespace = $true
+    $settings.IgnoreComments = $true
+    $reader = [System.Xml.XmlReader]::Create($dellCatalogXML, $settings)
+    $inDriver = $false
+    $inModel = $false
+    $depthModel = -1
+    $modelsHash = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
     try {
-        # Check if the Dell catalog XML exists and is recent
-        $downloadCatalog = $true
-        if (Test-Path -Path $dellCatalogXML -PathType Leaf) {
-            WriteLog "Dell Catalog XML found: $dellCatalogXML"
-            $dellCatalogCreationTime = (Get-Item $dellCatalogXML).CreationTime
-            WriteLog "Dell Catalog XML Creation time: $dellCatalogCreationTime"
-            # Check if the XML file is less than 7 days old
-            if (((Get-Date) - $dellCatalogCreationTime).TotalDays -lt 7) {
-                WriteLog "Using existing Dell Catalog XML (less than 7 days old): $dellCatalogXML"
-                $downloadCatalog = $false
-            }
-            else {
-                WriteLog "Existing Dell Catalog XML is older than 7 days: $dellCatalogXML"
-            }
-        }
-        else {
-            WriteLog "Dell Catalog XML not found: $dellCatalogXML"
-        }
-
-        if ($downloadCatalog) {
-            WriteLog "Attempting to download and extract Dell Catalog for Get-DellDriversModelList..."
-            # Ensure Dell drivers folder exists
-            if (-not (Test-Path -Path $dellDriversFolder -PathType Container)) {
-                WriteLog "Creating Dell drivers folder: $dellDriversFolder"
-                New-Item -Path $dellDriversFolder -ItemType Directory -Force | Out-Null
-            }
-
-            # Check URL accessibility
-            try {
-                $request = [System.Net.WebRequest]::Create($catalogUrl)
-                $request.Method = 'HEAD'; $response = $request.GetResponse(); $response.Close()
-            }
-            catch { throw "Dell Catalog URL '$catalogUrl' not accessible: $($_.Exception.Message)" }
-
-            # Remove existing files before download if they exist
-            if (Test-Path -Path $dellCabFile) { Remove-Item -Path $dellCabFile -Force -ErrorAction SilentlyContinue }
-            if (Test-Path -Path $dellCatalogXML) { Remove-Item -Path $dellCatalogXML -Force -ErrorAction SilentlyContinue }
-
-            WriteLog "Downloading Dell Catalog cab file: $catalogUrl to $dellCabFile"
-            Start-BitsTransferWithRetry -Source $catalogUrl -Destination $dellCabFile
-            WriteLog "Dell Catalog cab file downloaded to $dellCabFile"
-
-            WriteLog "Extracting Dell Catalog cab file '$dellCabFile' to '$dellCatalogXML'"
-            Invoke-Process -FilePath "Expand.exe" -ArgumentList """$dellCabFile"" ""$dellCatalogXML""" | Out-Null
-            WriteLog "Dell Catalog cab file extracted to $dellCatalogXML"
-
-            # Delete the CAB file after extraction
-            WriteLog "Deleting Dell Catalog CAB file: $dellCabFile"
-            Remove-Item -Path $dellCabFile -Force -ErrorAction SilentlyContinue
-        }
-
-        # Ensure the XML file exists before trying to read it
-        if (-not (Test-Path -Path $dellCatalogXML -PathType Leaf)) {
-            throw "Dell Catalog XML file '$dellCatalogXML' not found after download/check attempt."
-        }
-        
-        # Use XmlReader for streaming from the XML file
-        $settings = New-Object System.Xml.XmlReaderSettings
-        $settings.IgnoreWhitespace = $true
-        $settings.IgnoreComments = $true
-        # $settings.DtdProcessing = [System.Xml.DtdProcessing]::Ignore # Optional
-
-        $reader = [System.Xml.XmlReader]::Create($dellCatalogXML, $settings)
-        WriteLog "Starting XML stream parsing for Dell models from '$dellCatalogXML'..."
-
-        $isDriverComponent = $false
-        $isModelElement = $false
-        $modelDepth = -1 # Track depth to handle nested elements if needed
-
-        # Read through the XML stream node by node
         while ($reader.Read()) {
             switch ($reader.NodeType) {
                 ([System.Xml.XmlNodeType]::Element) {
                     switch ($reader.Name) {
-                        'SoftwareComponent' { $isDriverComponent = $false } # Reset flag
-                        'ComponentType' { if ($reader.GetAttribute('value') -eq 'DRVR') { $isDriverComponent = $true } }
-                        'Model' { if ($isDriverComponent) { $isModelElement = $true; $modelDepth = $reader.Depth } }
+                        'SoftwareComponent' { $inDriver = $false }
+                        'ComponentType' { if ($reader.GetAttribute('value') -eq 'DRVR') { $inDriver = $true } }
+                        'Model' { if ($inDriver) { $inModel = $true; $depthModel = $reader.Depth } }
                     }
                 }
                 ([System.Xml.XmlNodeType]::CDATA) {
-                    if ($isModelElement -and $isDriverComponent) {
-                        $modelName = $reader.Value.Trim()
-                        if (-not [string]::IsNullOrWhiteSpace($modelName)) { $uniqueModelNames.Add($modelName) | Out-Null }
-                        $isModelElement = $false # Reset after reading CDATA
+                    if ($inDriver -and $inModel) {
+                        $val = $reader.Value.Trim()
+                        if ($val) { $modelsHash.Add($val) | Out-Null }
+                        $inModel = $false
                     }
                 }
                 ([System.Xml.XmlNodeType]::EndElement) {
-                    switch ($reader.Name) {
-                        'SoftwareComponent' { $isDriverComponent = $false; $isModelElement = $false; $modelDepth = -1 }
-                        'Model' { if ($reader.Depth -eq $modelDepth) { $isModelElement = $false; $modelDepth = -1 } }
-                    }
+                    if ($reader.Name -eq 'SoftwareComponent') { $inDriver = $false; $inModel = $false }
+                    elseif ($reader.Name -eq 'Model' -and $reader.Depth -eq $depthModel) { $inModel = $false; $depthModel = -1 }
                 }
             }
-        } # End while ($reader.Read())
-
-        WriteLog "Finished XML stream parsing. Found $($uniqueModelNames.Count) unique Dell models."
-
-    }
-    catch {
-        WriteLog "Error getting Dell models: $($_.Exception.ToString())" # Log full exception
-        throw "Failed to retrieve Dell models. Check log for details." # Re-throw for UI handling
+        }
     }
     finally {
-        # Ensure the reader is closed and disposed
-        if ($null -ne $reader) {
-            $reader.Dispose()
-        }
-        # Ensure CAB file is deleted even if extraction failed but download succeeded
-        if (Test-Path -Path $dellCabFile) {
-            WriteLog "Cleaning up downloaded Dell CAB file: $dellCabFile"
-            Remove-Item -Path $dellCabFile -Force -ErrorAction SilentlyContinue
-        }
+        $reader.Dispose()
     }
 
-    # Convert HashSet to sorted list of PSCustomObjects
-    $models = [System.Collections.Generic.List[PSCustomObject]]::new()
-    foreach ($modelName in ($uniqueModelNames | Sort-Object)) {
-        $models.Add([PSCustomObject]@{
-                Make  = $Make
-                Model = $modelName
-                # Link is not applicable here like for Microsoft
-            })
+    $out = [System.Collections.Generic.List[pscustomobject]]::new()
+    foreach ($nm in ($modelsHash | Sort-Object)) {
+        $out.Add([pscustomobject]@{ Make = $Make; Model = $nm })
     }
-
-    return $models
+    return $out
 }
 
 # Function to download and extract drivers for a specific Dell model (Modified for ForEach-Object -Parallel)
@@ -160,548 +111,269 @@ function Save-DellDriversTask {
     [CmdletBinding()]
     param(
         [Parameter(Mandatory = $true)]
-        [PSCustomObject]$DriverItemData, # Contains Model property
+        [pscustomobject]$DriverItemData,
         [Parameter(Mandatory = $true)]
-        [string]$DriversFolder,         # Base drivers folder (e.g., C:\FFUDevelopment\Drivers)
+        [string]$DriversFolder,
         [Parameter(Mandatory = $true)]
         [string]$WindowsArch,
         [Parameter(Mandatory = $true)]
         [int]$WindowsRelease,
-        [Parameter()] # Made optional
-        [System.Collections.Concurrent.ConcurrentQueue[hashtable]]$ProgressQueue = $null, # Default to null
         [Parameter()]
-        [bool]$CompressToWim = $false # New parameter for compression
+        [System.Collections.Concurrent.ConcurrentQueue[hashtable]]$ProgressQueue = $null,
+        [Parameter()]
+        [bool]$CompressToWim = $false,
+        [Parameter()]
+        [bool]$PreserveSourceOnCompress = $false
     )
 
-    $modelName = $DriverItemData.Model
-    $make = "Dell" # Hardcoded for this task
-    $status = "Starting..." # Initial local status
-    $success = $false
+    $modelDisplay = $DriverItemData.Model
+    $make = 'Dell'
+    if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status 'Checking...' }
 
-    # Initial status update
-    if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status "Checking..." }
+    $sanitizedModelName = ConvertTo-SafeName -Name $modelDisplay
+    $makeDriversPath = Join-Path -Path $DriversFolder -ChildPath $make
+    $modelPath = Join-Path -Path $makeDriversPath -ChildPath $sanitizedModelName
+    $driverRelativePath = Join-Path -Path $make -ChildPath $sanitizedModelName
 
-    $makeDriversPath = Join-Path -Path $DriversFolder -ChildPath $Make
-    $modelPath = Join-Path -Path $makeDriversPath -ChildPath $modelName
-    $driverRelativePath = Join-Path -Path $make -ChildPath $modelName # Relative path for the driver folder
+    # Helper: safe folder removal
+    function Remove-SafeFolder {
+        param([string]$Path)
+        if ([string]::IsNullOrWhiteSpace($Path)) { return }
+        # Never allow deleting the entire Dell root folder accidentally
+        $dellRoot = (Resolve-Path $makeDriversPath).ProviderPath
+        $target = (Resolve-Path $Path -ErrorAction SilentlyContinue)?.ProviderPath
+        if ($null -eq $target) { return }
+        if ($target -eq $dellRoot) { return }
+        if (-not ($target.StartsWith($dellRoot, [System.StringComparison]::OrdinalIgnoreCase))) { return }
+        Remove-Item -Path $target -Recurse -Force -ErrorAction SilentlyContinue
+    }
 
     try {
-        # Check for existing drivers
-        $existingDriver = Test-ExistingDriver -Make $make -Model $modelName -DriversFolder $DriversFolder -Identifier $modelName -ProgressQueue $ProgressQueue
-        if ($null -ne $existingDriver) {
-            # Add the 'Model' property to the return object for consistency if it's not there
-            if (-not $existingDriver.PSObject.Properties['Model']) {
-                $existingDriver | Add-Member -MemberType NoteProperty -Name 'Model' -Value $modelName
+        # Existing drivers short‑circuit
+        $existing = Test-ExistingDriver -Make $make -Model $sanitizedModelName -DriversFolder $DriversFolder -Identifier $modelDisplay -ProgressQueue $ProgressQueue
+        if ($existing) {
+            if (-not $existing.PSObject.Properties['Model']) {
+                $existing | Add-Member -MemberType NoteProperty -Name 'Model' -Value $modelDisplay
             }
-
-            # Special handling for existing folders that need compression
-            if ($CompressToWim -and $existingDriver.Status -eq 'Already downloaded') {
-                $wimFilePath = Join-Path -Path $makeDriversPath -ChildPath "$($modelName).wim"
-                $sourceFolderPath = Join-Path -Path $makeDriversPath -ChildPath $modelName
-                WriteLog "Attempting compression of existing folder '$sourceFolderPath' to '$wimFilePath'."
-                if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status "Compressing existing..." }
+            if ($CompressToWim -and $existing.Status -eq 'Already downloaded') {
+                $wimPath = Join-Path $makeDriversPath "$sanitizedModelName.wim"
+                $wimRelativePath = Join-Path $make "$sanitizedModelName.wim"
+                $srcPath = Join-Path $makeDriversPath $sanitizedModelName
+                if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status 'Compressing existing...' }
                 try {
-                    Compress-DriverFolderToWim -SourceFolderPath $sourceFolderPath -DestinationWimPath $wimFilePath -WimName $modelName -WimDescription "Drivers for $modelName" -ErrorAction Stop
-                    $existingDriver.Status = "Already downloaded & Compressed"
-                    $existingDriver.DriverPath = Join-Path -Path $make -ChildPath "$($modelName).wim"
-                    $existingDriver.Success = $true
-                    WriteLog "Successfully compressed existing drivers for $modelName to $wimFilePath."
+                    $null = Compress-DriverFolderToWim -SourceFolderPath $srcPath -DestinationWimPath $wimPath -WimName $modelDisplay -WimDescription "Drivers for $modelDisplay" -PreserveSource:$PreserveSourceOnCompress -ErrorAction Stop
+                    $existing.Status = 'Compression successful'
+                    $existing.DriverPath = $wimRelativePath
+                    $existing.Success = $true
                 }
                 catch {
-                    WriteLog "Error compressing existing drivers for $($modelName): $($_.Exception.Message)"
-                    $existingDriver.Status = "Already downloaded (Compression failed)"
-                    $existingDriver.Success = $false
+                    WriteLog "Compression failed for $($modelDisplay): $($_.Exception.Message)"
+                    $existing.Status = 'Already downloaded (Compression failed)'
+                    $existing.Success = $false
                 }
-                if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $existingDriver.Status }
+                if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status $existing.Status }
             }
-
-            return $existingDriver
+            return $existing
         }
 
-        # Define paths for Dell catalog. The catalog is assumed to be prepared by the calling function.
-        $dellDriversFolder = Join-Path -Path $DriversFolder -ChildPath "Dell"
-        $catalogBaseName = if ($WindowsRelease -le 11) { "CatalogPC" } else { "Catalog" }
-        $dellCatalogXML = Join-Path -Path $dellDriversFolder -ChildPath "$($catalogBaseName).xml"
+        if (-not (Test-Path $makeDriversPath)) { New-Item -Path $makeDriversPath -ItemType Directory -Force | Out-Null }
+        if (-not (Test-Path $modelPath)) { New-Item -Path $modelPath -ItemType Directory -Force | Out-Null }
 
-        # 3. Parse the *EXISTING* XML and Find Drivers for *this specific model*
-        $status = "Finding drivers..."
-        if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
+        $packages = @()
 
-        # Check if the provided XML path exists
-        if (-not (Test-Path -Path $dellCatalogXML -PathType Leaf)) {
-            throw "Dell Catalog XML file not found at specified path: $dellCatalogXML"
-        }
-
-        WriteLog "Parsing existing Dell Catalog XML for model '$modelName' from: $dellCatalogXML"
-        
-        # Initialize variables
-        $baseLocation = $null
-        $latestDrivers = @{} # Hashtable to store latest drivers for this model
-        $modelSpecificDriversFound = $false
-        
-        # Create XML reader settings
-        $settings = New-Object System.Xml.XmlReaderSettings
-        $settings.IgnoreWhitespace = $true
-        $settings.IgnoreComments = $true
-        
-        # Create XML reader
-        $reader = $null
-        try {
-            $reader = [System.Xml.XmlReader]::Create($dellCatalogXML, $settings)
-            
-            # First pass - get baseLocation from manifest
-            while ($reader.Read()) {
-                if ($reader.NodeType -eq [System.Xml.XmlNodeType]::Element -and $reader.Name -eq "Manifest") {
-                    $baseLocationAttr = $reader.GetAttribute("baseLocation")
-                    if ($null -ne $baseLocationAttr) {
-                        $baseLocation = "https://" + $baseLocationAttr + "/"
-                        break
-                    }
+        if ($WindowsRelease -le 11) {
+            $cabUrl = $DriverItemData.CabUrl
+            if ([string]::IsNullOrWhiteSpace($cabUrl)) {
+                WriteLog "CabUrl missing for '$modelDisplay' – resolving via CatalogIndexPC."
+                $resolved = Resolve-DellCabUrlFromModel -DriversFolder $DriversFolder -ModelDisplay $modelDisplay
+                if ($null -eq $resolved -or [string]::IsNullOrWhiteSpace($resolved.CabUrl)) {
+                    throw "Unable to resolve CabUrl for $modelDisplay from CatalogIndexPC."
+                }
+                $cabUrl = $resolved.CabUrl
+                # Optionally persist back into the incoming object if property exists
+                if ($DriverItemData.PSObject.Properties['CabUrl']) {
+                    $DriverItemData.CabUrl = $cabUrl
                 }
             }
             
-            if ($null -eq $baseLocation) {
-                throw "Invalid Dell Catalog XML format: Missing 'baseLocation' attribute in Manifest element."
-            }
+            # Model-based workflow (always used for client pathway now)
+            $modelCabName = [IO.Path]::GetFileName($cabUrl)
+            if ([string]::IsNullOrWhiteSpace($modelCabName)) { throw "Derived model cab name empty for $modelDisplay" }
+            $modelCabPath = Join-Path $makeDriversPath $modelCabName
+            $modelXmlPath = Join-Path $makeDriversPath ([IO.Path]::GetFileNameWithoutExtension($modelCabName) + '.xml')
             
-            # Reset reader for second pass
-            $reader.Dispose()
-            $reader = [System.Xml.XmlReader]::Create($dellCatalogXML, $settings)
+            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status 'Downloading catalog...' }
+            if (Test-Path $modelCabPath) { Remove-SafeFolder $modelCabPath }
+            if (Test-Path $modelXmlPath) { Remove-SafeFolder $modelXmlPath }
             
-            # Process SoftwareComponents
-            while ($reader.Read()) {
-                if ($reader.NodeType -eq [System.Xml.XmlNodeType]::Element -and $reader.Name -eq "SoftwareComponent") {
-                    # Read the entire SoftwareComponent subtree
-                    $componentXml = $reader.ReadSubtree()
-                    $component = New-Object System.Xml.XmlDocument
-                    $component.Load($componentXml)
-                    $componentXml.Dispose()
+            WriteLog "Downloading Dell model catalog from $cabUrl to $modelCabPath"
+            Start-BitsTransferWithRetry -Source $cabUrl -Destination $modelCabPath
+            Invoke-Process -FilePath Expand.exe -ArgumentList """$modelCabPath"" ""$modelXmlPath""" | Out-Null
+            Remove-Item $modelCabPath -Force -ErrorAction SilentlyContinue
+            if (-not (Test-Path $modelXmlPath)) { throw "Model XML not found after extraction: $modelXmlPath" }
 
-                    # Check if it's a driver component
-                    $componentTypeNode = $component.SelectSingleNode("//ComponentType[@value='DRVR']")
-                    if ($null -eq $componentTypeNode) {
-                        continue
-                    }
-                    
-                    # Check if component supports the model
-                    $modelNodes = $component.SelectNodes("//SupportedSystems/Brand/Model")
-                    $modelMatch = $false
-                    
-                    foreach ($modelNode in $modelNodes) {
-                        $displayNode = $modelNode.SelectSingleNode("Display")
-                        if ($null -ne $displayNode -and $displayNode.InnerText.Trim() -eq $modelName) {
-                            $modelMatch = $true
-                            break
-                        }
-                    }
-                    
-                    if ($modelMatch) {
-                        # Check OS compatibility
-                        $validOS = $null
-                        $osNodes = $component.SelectNodes("//SupportedOperatingSystems/OperatingSystem")
-                        
-                        if ($null -ne $osNodes) {
-                            foreach ($osNode in $osNodes) {
-                                $osArch = $osNode.GetAttribute("osArch")
-                                
-                                if ($WindowsRelease -le 11) {
-                                    # Client OS check
-                                    if ($osArch -eq $WindowsArch) {
-                                        $validOS = $osNode
-                                        break
-                                    }
-                                }
-                                else {
-                                    # Server OS check
-                                    $osCode = $osNode.GetAttribute("osCode")
-                                    $osCodePattern = switch ($WindowsRelease) {
-                                        2016 { "W14" }
-                                        2019 { "W19" }
-                                        2022 { "W22" }
-                                        2025 { "W25" }
-                                        default { "W22" }
-                                    }
-                                    if ($osArch -eq $WindowsArch -and $osCode -match $osCodePattern) {
-                                        $validOS = $osNode
-                                        break
-                                    }
-                                }
-                            }
-                        }
-                        
-                        if ($validOS) {
-                            $modelSpecificDriversFound = $true
-                            
-                            # Extract driver information
-                            $driverPath = $component.SoftwareComponent.GetAttribute("path")
-                            $downloadUrl = $baseLocation + $driverPath
-                            $driverFileName = [System.IO.Path]::GetFileName($driverPath)
-                            
-                            # Get name
-                            $nameNode = $component.SelectSingleNode("//Name/Display")
-                            $name = if ($null -ne $nameNode) { $nameNode.InnerText } else { "UnknownDriver" }
-                            $name = $name -replace '[\\\/\:\*\?\"\<\>\| ]', '_' -replace '[\,]', '-'
-                            
-                            # Get category
-                            $categoryNode = $component.SelectSingleNode("//Category/Display")
-                            $category = if ($null -ne $categoryNode) { $categoryNode.InnerText } else { "Uncategorized" }
-                            $category = $category -replace '[\\\/\:\*\?\"\<\>\| ]', '_'
-                            
-                            # Get version
-                            $version = [version]"0.0"
-                            $vendorVersion = $component.SoftwareComponent.GetAttribute("vendorVersion")
-                            if ($null -ne $vendorVersion) {
-                                try { $version = [version]$vendorVersion } catch { WriteLog "Warning: Could not parse version '$vendorVersion' for driver '$name'. Using 0.0." }
-                            }
-                            
-                            $namePrefix = ($name -split '-')[0]
-                            
-                            # Store the latest version for each category/prefix combination
-                            if (-not $latestDrivers.ContainsKey($category)) { $latestDrivers[$category] = @{} }
-                            if (-not $latestDrivers[$category].ContainsKey($namePrefix) -or $latestDrivers[$category][$namePrefix].Version -lt $version) {
-                                $latestDrivers[$category][$namePrefix] = [PSCustomObject]@{
-                                    Name           = $name
-                                    DownloadUrl    = $downloadUrl
-                                    DriverFileName = $driverFileName
-                                    Version        = $version
-                                    Category       = $category
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        finally {
-            if ($null -ne $reader) {
-                $reader.Dispose()
-            }
-        }
-
-        WriteLog "Searching $($softwareComponents.Count) DRVR components in '$dellCatalogXML' for model '$modelName'..."
-
-        foreach ($component in $softwareComponents) {
-            # Check if SupportedSystems and Brand exist
-            if ($null -eq $component.SupportedSystems -or $null -eq $component.SupportedSystems.Brand) { continue }
-            # Ensure Model is iterable
-            $componentModels = @($component.SupportedSystems.Brand.Model)
-            if ($null -eq $componentModels) { continue }
-
-            $modelMatch = $false
-            foreach ($item in $componentModels) {
-                # Check if Display and its CDATA section exist before accessing
-                if ($null -ne $item.Display -and $null -ne $item.Display.'#cdata-section' -and $item.Display.'#cdata-section'.Trim() -eq $modelName) {
-                    $modelMatch = $true
-                    break
-                }
-            }
-
-            if ($modelMatch) {
-                # Model matches, now check OS compatibility
-                $validOS = $null
-                if ($null -ne $component.SupportedOperatingSystems) {
-                    # Ensure OperatingSystem is always an array/collection
-                    $osList = @($component.SupportedOperatingSystems.OperatingSystem)
-
-                    if ($null -ne $osList) {
-                        if ($WindowsRelease -le 11) {
-                            # Client OS check
-                            $validOS = $osList | Where-Object { $_.osArch -eq $WindowsArch } | Select-Object -First 1
-                        }
-                        else {
-                            # Server OS check
-                            $osCodePattern = switch ($WindowsRelease) {
-                                2016 { "W14" } # Note: Dell uses W14 for Server 2016
-                                2019 { "W19" }
-                                2022 { "W22" }
-                                2025 { "W25" }
-                                default { "W22" } # Fallback, adjust as needed
-                            }
-                            $validOS = $osList | Where-Object { ($_.osArch -eq $WindowsArch) -and ($_.osCode -match $osCodePattern) } | Select-Object -First 1
-                        }
-                    }
-                }
-
-                if ($validOS) {
-                    $modelSpecificDriversFound = $true # Mark that we found at least one relevant driver component
-                    $driverPath = $component.path
-                    $downloadUrl = $baseLocation + $driverPath
-                    $driverFileName = [System.IO.Path]::GetFileName($driverPath)
-                    # Check if Name, Display, and CDATA exist
-                    $name = "UnknownDriver" # Default name
-                    if ($null -ne $component.Name -and $null -ne $component.Name.Display -and $null -ne $component.Name.Display.'#cdata-section') {
-                        $name = $component.Name.Display.'#cdata-section'
-                        $name = $name -replace '[\\\/\:\*\?\"\<\>\| ]', '_' -replace '[\,]', '-'
-                    }
-                    # Check if Category, Display, and CDATA exist
-                    $category = "Uncategorized" # Default category
-                    if ($null -ne $component.Category -and $null -ne $component.Category.Display -and $null -ne $component.Category.Display.'#cdata-section') {
-                        $category = $component.Category.Display.'#cdata-section'
-                        $category = $category -replace '[\\\/\:\*\?\"\<\>\| ]', '_'
-                    }
-                    $version = [version]"0.0" # Default version
-                    if ($null -ne $component.vendorVersion) {
-                        try { $version = [version]$component.vendorVersion } catch { WriteLog "Warning: Could not parse version '$($component.vendorVersion)' for driver '$name'. Using 0.0." }
-                    }
-                    $namePrefix = ($name -split '-')[0] # Group by prefix within category
-
-                    # Store the latest version for each category/prefix combination
-                    if (-not $latestDrivers.ContainsKey($category)) { $latestDrivers[$category] = @{} }
-                    if (-not $latestDrivers[$category].ContainsKey($namePrefix) -or $latestDrivers[$category][$namePrefix].Version -lt $version) {
-                        $latestDrivers[$category][$namePrefix] = [PSCustomObject]@{
-                            Name           = $name
-                            DownloadUrl    = $downloadUrl
-                            DriverFileName = $driverFileName
-                            Version        = $version
-                            Category       = $category
-                        }
-                    }
-                }
-            } # End if ($modelMatch)
-        } # End foreach ($component in $softwareComponents)
-
-        if (-not $modelSpecificDriversFound) {
-            $status = "No drivers found for OS"
-            WriteLog "No drivers found for model '$modelName' matching Windows Release '$WindowsRelease' and Arch '$WindowsArch' in '$dellCatalogXML'."
-            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
-            # Consider this success as the process completed, just no drivers to download
-            return [PSCustomObject]@{ Model = $modelName; Status = $status; Success = $true }
-        }
-
-        # 4. Download and Extract Found Drivers (Logic remains largely the same)
-        $totalDriversToProcess = ($latestDrivers.Values | ForEach-Object { $_.Values.Count } | Measure-Object -Sum).Sum
-        $driversProcessed = 0
-        WriteLog "Found $totalDriversToProcess latest driver packages to download for $modelName."
-
-        # Ensure base directories exist before loop
-        if (-not (Test-Path -Path $makeDriversPath)) { New-Item -Path $makeDriversPath -ItemType Directory -Force | Out-Null }
-        if (-not (Test-Path -Path $modelPath)) { New-Item -Path $modelPath -ItemType Directory -Force | Out-Null }
-
-        foreach ($category in $latestDrivers.Keys) {
-            foreach ($driver in $latestDrivers[$category].Values) {
-                $driversProcessed++
-                $status = "Downloading $($driversProcessed)/$($totalDriversToProcess): $($driver.Name)"
-                if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
-
-                $downloadFolder = Join-Path -Path $modelPath -ChildPath $driver.Category
-                $driverFilePath = Join-Path -Path $downloadFolder -ChildPath $driver.DriverFileName
-                $extractFolder = Join-Path -Path $downloadFolder -ChildPath $driver.DriverFileName.TrimEnd($driver.DriverFileName[-4..-1])
-
-                # Check if already extracted (more robust check)
-                if (Test-Path -Path $extractFolder -PathType Container) {
-                    $extractSize = (Get-ChildItem -Path $extractFolder -Recurse -Exclude *.log | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
-                    if ($extractSize -gt 1KB) {
-                        WriteLog "Driver already extracted: $($driver.Name) in $extractFolder. Skipping."
-                        continue # Skip to next driver
-                    }
-                }
-                # Check if download file exists but extraction folder doesn't or is empty
-                if (Test-Path -Path $driverFilePath -PathType Leaf) {
-                    WriteLog "Download file $($driver.DriverFileName) exists, but extraction folder '$extractFolder' is missing or empty. Will attempt extraction."
-                    # Proceed to extraction logic below
-                }
-                else {
-                    # Download the driver
-                    WriteLog "Downloading driver: $($driver.Name) ($($driver.DriverFileName))"
-                    if (-not (Test-Path -Path $downloadFolder)) {
-                        WriteLog "Creating download folder: $downloadFolder"
-                        New-Item -Path $downloadFolder -ItemType Directory -Force | Out-Null
-                    }
-                    WriteLog "Downloading from: $($driver.DownloadUrl) to $driverFilePath"
-                    try {
-                        Start-BitsTransferWithRetry -Source $driver.DownloadUrl -Destination $driverFilePath
-                        WriteLog "Driver downloaded: $($driver.DriverFileName)"
-                    }
-                    catch {
-                        WriteLog "Failed to download driver: $($driver.DownloadUrl). Error: $($_.Exception.Message). Skipping."
-                        # Update status for this specific driver failure? Maybe too granular.
-                        continue # Skip to next driver
-                    }
-                }
-
-
-                # Extract the driver
-                $status = "Extracting $($driversProcessed)/$($totalDriversToProcess): $($driver.Name)"
-                if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
-                
-                # Ensure extraction folder exists before attempting extraction
-                if (-not (Test-Path -Path $extractFolder)) {
-                    WriteLog "Creating extraction folder: $extractFolder"
-                    New-Item -Path $extractFolder -ItemType Directory -Force | Out-Null
-                }
-
-                # Dell uses /e to extact the entire DUP while /drivers to extract only the drivers
-                # In many cases /drivers will extract drivers for mutliple OS versions
-                # Which can cause many duplicate files and bloat your driver folder
-                # /e seems to be better and only extracts what is necessary and has less issues
-                # We will default to using /e, but will fall back to /drivers if content cannot be found
-
-                $arguments = "/s /e=`"$extractFolder`" /l=`"$extractFolder\log.log`""
-                $altArguments = "/s /drivers=`"$extractFolder`" /l=`"$extractFolder\log.log`""
-                $extractionSuccess = $false
-                try {
-                    # Handle special cases (Chipset/Network) - Check if OS is Server
-                    $osInfo = Get-CimInstance -ClassName Win32_OperatingSystem # Get OS info within the task scope
-                    $isServer = $osInfo.Caption -match 'server'
-                    
-                    # Chipset drivers may require killing child processes in some cases
-                    if ($driver.Category -eq "Chipset") {
-                        WriteLog "Extracting Chipset driver: $driverFilePath $arguments"
-                        $process = Invoke-Process -FilePath $driverFilePath -ArgumentList $arguments -Wait $false
-                        Start-Sleep -Seconds 5 # Allow time for extraction
-                        WriteLog "Extraction exited with exit code: $($process.ExitCode)"
-                        # Attempt to gracefully close child process if needed (logic from original script)
-                        $childProcesses = Get-CimInstance Win32_Process -Filter "ParentProcessId = $($process.Id)"
-                        if ($childProcesses) {
-                            $latestProcess = $childProcesses | Sort-Object CreationDate -Descending | Select-Object -First 1
-                            WriteLog "Stopping child process for Chipset driver: $($latestProcess.Name) (PID: $($latestProcess.ProcessId))"
-                            Stop-Process -Id $latestProcess.ProcessId -Force -ErrorAction SilentlyContinue
-                            Start-Sleep -Seconds 1
-                        }
-                    }
-                    # Network drivers on client OS may require killing child processes
-                    elseif ($driver.Category -eq "Network" -and -not $isServer) {
-                        WriteLog "Extracting Network driver: $driverFilePath $arguments"
-                        $process = Invoke-Process -FilePath $driverFilePath -ArgumentList $arguments -Wait $false
-                        Start-Sleep -Seconds 5
-                        WriteLog "Extraction exited with exit code: $($process.ExitCode)"
-                        if (-not $process.HasExited) {
-                            $childProcesses = Get-CimInstance Win32_Process -Filter "ParentProcessId = $($process.Id)"
-                            if ($childProcesses) {
-                                $latestProcess = $childProcesses | Sort-Object CreationDate -Descending | Select-Object -First 1
-                                WriteLog "Stopping child process for Network driver: $($latestProcess.Name) (PID: $($latestProcess.ProcessId))"
-                                Stop-Process -Id $latestProcess.ProcessId -Force -ErrorAction SilentlyContinue
-                                Start-Sleep -Seconds 1
-                            }
-                        }
-                    }
-                    else {
-                        WriteLog "Extracting driver: $driverFilePath $arguments"
-                        $process = Invoke-Process -FilePath $driverFilePath -ArgumentList $arguments
-                        WriteLog "Extraction exited with exit code: $($process.ExitCode)"
-                    }
-
-                    # Verify extraction (check if folder has content)
-                    if (Test-Path -Path $extractFolder -PathType Container) {
-                        $extractSize = (Get-ChildItem -Path $extractFolder -Recurse -Exclude *.log | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
-                        if ($extractSize -gt 1KB) {
-                            $extractionSuccess = $true
-                            WriteLog "Extraction successful (Method 1) for $driverFilePath $arguments"
-                        }
-                    }
-
-                    # If primary extraction failed or folder is empty, try alternative
-                    if (-not $extractionSuccess) {
-                        # $arguments = "/s /e=`"$extractFolder`""
-                        # $altArguments = "/s /drivers=`"$extractFolder`""
-                        WriteLog "Extraction with $arguments failed or resulted in empty folder for $driverFilePath. Retrying with $altArguments"
-                        # Clean up potentially empty folder before retrying
-                        Remove-Item -Path $extractFolder -Recurse -Force -ErrorAction SilentlyContinue
-                        New-Item -Path $extractFolder -ItemType Directory -Force | Out-Null # Recreate empty folder
-                        $process = Invoke-Process -FilePath $driverFilePath -ArgumentList $altArguments
-                        WriteLog "Extraction exited with exit code: $($process.ExitCode)"
-
-                        # Verify extraction again
-                        if (Test-Path -Path $extractFolder -PathType Container) {
-                            $extractSize = (Get-ChildItem -Path $extractFolder -Recurse -Exclude *.log | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
-                            if ($extractSize -gt 1KB) {
-                                $extractionSuccess = $true
-                                WriteLog "Extraction successful (Method 2) for $driverFilePath $altArguments"
-                            }
-                        }
-                    }
-                }
-                catch {
-                    WriteLog "Error during extraction process for $($driver.DriverFileName): $($_.Exception.Message). Trying alternative method."
-                    # Try alternative method on any error during the first attempt block
-                    try {
-                        if (Test-Path -Path $extractFolder) {
-                            # Clean up before retry if needed
-                            Remove-Item -Path $extractFolder -Recurse -Force -ErrorAction SilentlyContinue
-                        }
-                        New-Item -Path $extractFolder -ItemType Directory -Force | Out-Null
-                        # $arguments = "/s /e=`"$extractFolder`""
-                        # $altArguments = "/s /drivers=`"$extractFolder`""
-                        WriteLog "Extracting driver (Method 2): $driverFilePath $altArguments"
-                        $process = Invoke-Process -FilePath $driverFilePath -ArgumentList $altArguments
-                        WriteLog "Extraction exited with exit code: $($process.ExitCode)"
-
-                        # Verify extraction again
-                        if (Test-Path -Path $extractFolder -PathType Container) {
-                            $extractSize = (Get-ChildItem -Path $extractFolder -Recurse -Exclude *.log | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
-                            if ($extractSize -gt 1KB) {
-                                $extractionSuccess = $true
-                                WriteLog "Extraction successful (Method 2) for $driverFilePath."
-                            }
-                        }
-                    }
-                    catch {
-                        WriteLog "Alternative extraction method also failed for $($driver.DriverFileName): $($_.Exception.Message)."
-                        # Extraction failed completely
-                    }
-                }
-
-                # Cleanup downloaded file only if extraction was successful
-                if ($extractionSuccess) {
-                    WriteLog "Deleting driver file: $driverFilePath"
-                    Remove-Item -Path $driverFilePath -Force -ErrorAction SilentlyContinue
-                    WriteLog "Driver file deleted: $driverFilePath"
-                }
-                else {
-                    WriteLog "Extraction failed for $($driver.DriverFileName). Downloaded file kept at $driverFilePath for inspection."
-                    # Update status to indicate partial failure?
-                }
-
-            } # End foreach ($driver in $latestDrivers)
-        } # End foreach ($category in $latestDrivers)
-            
-        # --- Compress to WIM if requested (after all drivers processed) ---
-        if ($CompressToWim) {
-            $status = "Compressing..."
-            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
-            $wimFileName = "$($modelName).wim"
-            $destinationWimPath = Join-Path -Path $makeDriversPath -ChildPath $wimFileName
-            $driverRelativePath = Join-Path -Path $make -ChildPath $wimFileName # Update relative path to the WIM file
-            WriteLog "Compressing '$modelPath' to '$destinationWimPath'..."
+            # Track extracted model XML so cancel cleanup can remove it even if file timestamps are preserved from source metadata.
             try {
-                $compressResult = Compress-DriverFolderToWim -SourceFolderPath $modelPath -DestinationWimPath $destinationWimPath -WimName $modelName -WimDescription $modelName -ErrorAction Stop
-                if ($compressResult) {
-                    WriteLog "Compression successful for '$modelName'."
-                    $status = "Completed & Compressed"
+                Register-CurrentRunDownloadTarget -Destination $modelXmlPath
+            }
+            catch {
+                WriteLog "Failed to register Dell model XML for current-run cleanup ($modelXmlPath): $($_.Exception.Message)"
+            }
+            
+            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status 'Selecting latest drivers...' }
+            $packages = Get-DellLatestDriverPackages -ModelXmlPath $modelXmlPath -WindowsArch $WindowsArch -WindowsRelease $WindowsRelease
+        }
+        else {
+            # Server legacy logic unchanged (kept as before)
+            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status 'Preparing server catalog...' }
+            $catalogCab = Join-Path $makeDriversPath 'Catalog.cab'
+            $catalogXml = Join-Path $makeDriversPath 'Catalog.xml'
+            $catalogUrl = 'https://downloads.dell.com/catalog/Catalog.cab'
+            $need = $true
+            if (Test-Path $catalogXml) {
+                if (((Get-Date) - (Get-Item $catalogXml).CreationTime).TotalDays -lt 7) { $need = $false }
+            }
+            if ($need) {
+                if (Test-Path $catalogCab) { Remove-SafeFolder $catalogCab }
+                if (Test-Path $catalogXml) { Remove-SafeFolder $catalogXml }
+                WriteLog "Downloading Dell server catalog from $catalogUrl to $catalogCab"
+                Start-BitsTransferWithRetry -Source $catalogUrl -Destination $catalogCab
+                Invoke-Process -FilePath Expand.exe -ArgumentList """$catalogCab"" ""$catalogXml""" | Out-Null
+                Remove-Item $catalogCab -Force -ErrorAction SilentlyContinue
+            }
+            if (-not (Test-Path $catalogXml)) { throw "Server catalog XML missing: $catalogXml" }
+
+            [xml]$xmlContent = Get-Content -Path $catalogXml -Raw
+            $baseLocation = "https://$($xmlContent.manifest.baseLocation)/"
+            $softwareComponents = $xmlContent.Manifest.SoftwareComponent | Where-Object { $_.ComponentType.value -eq 'DRVR' }
+            $latestDrivers = @{}
+            foreach ($component in $softwareComponents) {
+                $models = $component.SupportedSystems.Brand.Model
+                foreach ($m in $models) {
+                    if ($m.Display.'#cdata-section' -eq $modelDisplay) {
+                        $validOS = $component.SupportedOperatingSystems.OperatingSystem | Where-Object { $_.osArch -eq $WindowsArch }
+                        if (-not $validOS) { continue }
+                        $driverPath = $component.path
+                        $downloadUrl = $baseLocation + $driverPath
+                        $fileName = [IO.Path]::GetFileName($driverPath)
+                        $name = $component.Name.Display.'#cdata-section' -replace '[\\\/\:\*\?\"\<\>\| ]', '_' -replace '[\,]', '-'
+                        $category = $component.Category.Display.'#cdata-section' -replace '[\\\/\:\*\?\"\<\>\| ]', '_'
+                        $version = [version]$component.vendorVersion
+                        $namePrefix = ($name -split '-')[0]
+                        if (-not $latestDrivers[$category]) { $latestDrivers[$category] = @{} }
+                        if (-not $latestDrivers[$category][$namePrefix] -or $latestDrivers[$category][$namePrefix].Version -lt $version) {
+                            $latestDrivers[$category][$namePrefix] = [pscustomobject]@{
+                                Name           = $name
+                                DownloadUrl    = $downloadUrl
+                                DriverFileName = $fileName
+                                Version        = $version
+                                Category       = $category
+                            }
+                        }
+                    }
                 }
-                else {
-                    WriteLog "Compression failed for '$modelName'. Check verbose/error output from Compress-DriverFolderToWim."
-                    $status = "Completed (Compression Failed)"
+            }
+            foreach ($cat in $latestDrivers.Keys) { foreach ($drv in $latestDrivers[$cat].Values) { $packages += $drv } }
+        }
+
+        if (-not $packages -or $packages.Count -eq 0) {
+            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status 'No drivers found for OS' }
+            return [pscustomobject]@{ Model = $modelDisplay; Status = 'No drivers found for OS'; Success = $true; DriverPath = $driverRelativePath }
+        }
+
+        $total = $packages.Count
+        $idx = 0
+        foreach ($pkg in $packages) {
+            $idx++
+            $driverName = $pkg.Name
+            if ([string]::IsNullOrWhiteSpace($driverName)) { $driverName = $pkg.DriverFileName }
+            $status = "$idx/$total Downloading $driverName"
+            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status $status }
+
+            $categorySafe = ($pkg.Category -replace '[\\\/\:\*\?\"\<\>\| ]', '_')
+            $downloadFolder = Join-Path $modelPath $categorySafe
+            if (-not (Test-Path $downloadFolder)) { New-Item -Path $downloadFolder -ItemType Directory -Force | Out-Null }
+            $driverFilePath = Join-Path $downloadFolder $pkg.DriverFileName
+            $plainName = [IO.Path]::GetFileNameWithoutExtension($pkg.DriverFileName)
+            if ([string]::IsNullOrWhiteSpace($plainName)) { $plainName = "_extract" }
+            $extractFolder = Join-Path $downloadFolder $plainName
+
+            if (Test-Path $extractFolder) {
+                $sz = (Get-ChildItem -Path $extractFolder -Recurse -Exclude *.log | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
+                if ($sz -gt 1KB) { continue }
+            }
+
+            if (-not (Test-Path $driverFilePath)) {
+                WriteLog "$status URL: $($pkg.DownloadUrl)"
+                try { Start-BitsTransferWithRetry -Source $pkg.DownloadUrl -Destination $driverFilePath }
+                catch {
+                    $failureMessage = "Failed to download driver '$driverName' from $($pkg.DownloadUrl): $($_.Exception.Message)"
+                    WriteLog $failureMessage
+                    throw (New-Object System.Exception($failureMessage, $_.Exception))
+                }
+            }
+
+            $status = "$idx/$total Extracting $driverName"
+            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status $status }
+
+            if (-not (Test-Path $extractFolder)) { New-Item -Path $extractFolder -ItemType Directory -Force | Out-Null }
+
+            $arg1 = "/s /e=`"$extractFolder`" /l=`"$extractFolder\log.log`""
+            $arg2 = "/s /drivers=`"$extractFolder`" /l=`"$extractFolder\log.log`""
+            $ok = $false
+            try {
+                Invoke-Process -FilePath $driverFilePath -ArgumentList $arg1 | Out-Null
+                $sz = (Get-ChildItem -Path $extractFolder -Recurse -Exclude *.log | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
+                if ($sz -gt 1KB) { $ok = $true }
+                if (-not $ok) {
+                    Remove-SafeFolder $extractFolder
+                    New-Item -Path $extractFolder -ItemType Directory -Force | Out-Null
+                    Invoke-Process -FilePath $driverFilePath -ArgumentList $arg2 | Out-Null
+                    $sz = (Get-ChildItem -Path $extractFolder -Recurse -Exclude *.log | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
+                    if ($sz -gt 1KB) { $ok = $true }
                 }
             }
             catch {
-                WriteLog "Error during compression for '$modelName': $($_.Exception.Message)"
-                $status = "Completed (Compression Error)"
+                WriteLog "Extraction error: $($_.Exception.Message)"
+            }
+
+            if ($ok) {
+                Remove-Item $driverFilePath -Force -ErrorAction SilentlyContinue
+            }
+            else {
+                $failureMessage = "Failed to extract driver '$driverName'."
+                WriteLog $failureMessage
+                throw (New-Object System.Exception($failureMessage))
+            }
+        }
+
+        if ($CompressToWim) {
+            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status 'Compressing...' }
+            $wimPath = Join-Path $makeDriversPath "$sanitizedModelName.wim"
+            try {
+                $null = Compress-DriverFolderToWim -SourceFolderPath $modelPath -DestinationWimPath $wimPath -WimName $modelDisplay -WimDescription $modelDisplay -PreserveSource:$PreserveSourceOnCompress -ErrorAction Stop
+                $driverRelativePath = Join-Path $make "$sanitizedModelName.wim"
+                $statusFinal = 'Completed & Compressed'
+            }
+            catch {
+                WriteLog "Compression failed for $($modelDisplay): $($_.Exception.Message)"
+                $statusFinal = 'Completed (Compression Failed)'
             }
         }
         else {
-            $status = "Completed" # Final status if not compressing
+            $statusFinal = 'Completed'
         }
-        # --- End Compression ---
-            
-        $success = $true # Mark success as download/extract was okay
 
+        if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status $statusFinal }
+        return [pscustomobject]@{ Model = $modelDisplay; Status = $statusFinal; Success = $true; DriverPath = $driverRelativePath }
     }
     catch {
-        $status = "Error: $($_.Exception.Message.Split('.')[0])" # Shorten error message
-        WriteLog "Error saving Dell drivers for $($modelName): $($_.Exception.ToString())" # Log full exception string
-        $success = $false
-        # Enqueue the error status before returning
-        if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
-        # Ensure return object is created even on error
-        return [PSCustomObject]@{ Model = $modelName; Status = $status; Success = $success; DriverPath = $null }
+        $errorStatus = "Error: $($_.Exception.Message)"
+        WriteLog "Save-DellDriversTask error for $($modelDisplay): $($_.Exception.ToString())"
+        Remove-DriverModelFolder -DriversFolder $DriversFolder -TargetFolder $modelPath -Description $modelDisplay
+        if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelDisplay -Status $errorStatus }
+        return [pscustomobject]@{ Model = $modelDisplay; Status = $errorStatus; Success = $false; DriverPath = $null }
     }
-
-    # Enqueue the final status (success or error) before returning
-    if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
-
-    # Return the final status
-    return [PSCustomObject]@{ Model = $modelName; Status = $status; Success = $success; DriverPath = $driverRelativePath }
 }
 
 Export-ModuleMember -Function *

FFUDevelopment/FFUUI.Core/FFUUI.Core.Drivers.HP.psm1

@@ -66,30 +66,45 @@ function Get-HPDriversModelList {
         $settings.Async = $false # Ensure synchronous reading
 
         $reader = [System.Xml.XmlReader]::Create($platformListXml, $settings)
-        $uniqueModels = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
+        $uniqueEntries = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
 
         while ($reader.Read()) {
             if ($reader.NodeType -eq [System.Xml.XmlNodeType]::Element -and $reader.Name -eq 'Platform') {
-                # Read the inner content of the Platform node
                 $platformReader = $reader.ReadSubtree()
+                $platformNames = [System.Collections.Generic.List[string]]::new()
+                $platformSystemId = $null
+
                 while ($platformReader.Read()) {
-                    if ($platformReader.NodeType -eq [System.Xml.XmlNodeType]::Element -and $platformReader.Name -eq 'ProductName') {
-                        $modelName = $platformReader.ReadElementContentAsString()
-                        if (-not [string]::IsNullOrWhiteSpace($modelName) -and $uniqueModels.Add($modelName)) {
-                            # Add to list only if it's a new unique model
-                            $modelList.Add([PSCustomObject]@{
-                                    Make  = $Make
-                                    Model = $modelName
-                                })
+                    if ($platformReader.NodeType -eq [System.Xml.XmlNodeType]::Element) {
+                        if ($platformReader.Name -eq 'ProductName') {
+                            $modelName = $platformReader.ReadElementContentAsString()
+                            if (-not [string]::IsNullOrWhiteSpace($modelName)) {
+                                $platformNames.Add($modelName.Trim())
+                            }
+                        }
+                        elseif ($platformReader.Name -eq 'SystemID') {
+                            $platformSystemId = $platformReader.ReadElementContentAsString().Trim()
                         }
                     }
                 }
                 $platformReader.Close()
+
+                foreach ($name in $platformNames) {
+                    $systemIdKey = if (-not [string]::IsNullOrWhiteSpace($platformSystemId)) { $platformSystemId } else { '' }
+                    $compositeKey = "$name|$systemIdKey"
+                    if ($uniqueEntries.Add($compositeKey)) {
+                        $modelList.Add([PSCustomObject]@{
+                                Make     = $Make
+                                Model    = $name
+                                SystemId = $platformSystemId
+                            })
+                    }
+                }
             }
         }
         $reader.Close()
 
-        WriteLog "Successfully parsed $($modelList.Count) unique HP models from PlatformList.xml."
+        WriteLog "Successfully parsed $($modelList.Count) HP model and SystemID combinations from PlatformList.xml."
 
     }
     catch {
@@ -97,7 +112,7 @@ function Get-HPDriversModelList {
     }
 
     # Sort the list alphabetically by Model name before returning
-    return $modelList | Sort-Object -Property Model
+    return $modelList | Sort-Object -Property Model, SystemId
 }
 # Function to download and extract drivers for a specific HP model (Designed for ForEach-Object -Parallel)
 function Save-HPDriversTask {
@@ -118,13 +133,22 @@ function Save-HPDriversTask {
         [Parameter()] # Made optional
         [System.Collections.Concurrent.ConcurrentQueue[hashtable]]$ProgressQueue = $null, # Default to null
         [Parameter()]
-        [bool]$CompressToWim = $false # New parameter for compression
+        [bool]$CompressToWim = $false, # New parameter for compression
+        [Parameter()]
+        [bool]$PreserveSourceOnCompress = $false
     )
             
-    $modelName = $DriverItemData.Model
+    $displayModelName = if (-not [string]::IsNullOrWhiteSpace($DriverItemData.Model)) { $DriverItemData.Model } else { $DriverItemData.Id }
     $make = $DriverItemData.Make # Should be 'HP'
-    $identifier = $modelName # Unique identifier for progress updates
-    $sanitizedModelName = $modelName -replace '[\\/:"*?<>|]', '_'
+    $productName = if ($DriverItemData.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($DriverItemData.ProductName)) { $DriverItemData.ProductName } else { ConvertTo-DriverBaseName -ModelString $displayModelName }
+    if ([string]::IsNullOrWhiteSpace($productName)) { $productName = $displayModelName }
+    $systemIdentifier = if ($DriverItemData.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($DriverItemData.SystemId)) { $DriverItemData.SystemId } else { $null }
+    if ([string]::IsNullOrWhiteSpace($displayModelName)) {
+        $displayModelName = if ([string]::IsNullOrWhiteSpace($systemIdentifier)) { $productName } else { Get-DriverDisplayName -BaseName $productName -Identifier $systemIdentifier }
+    }
+    $identifier = $displayModelName # Unique identifier for progress updates
+    $sanitizedModelName = ConvertTo-SafeName -Name $identifier
+    if ($sanitizedModelName -ne $identifier) { WriteLog "Sanitized model name: '$identifier' -> '$sanitizedModelName'" }
     $hpDriversBaseFolder = Join-Path -Path $DriversFolder -ChildPath $make # Changed variable name for clarity
     $platformListXml = Join-Path -Path $hpDriversBaseFolder -ChildPath "PlatformList.xml"
     $modelSpecificFolder = Join-Path -Path $hpDriversBaseFolder -ChildPath $sanitizedModelName # Sanitize model name for folder path
@@ -132,7 +156,16 @@ function Save-HPDriversTask {
     $finalStatus = "" # Initialize final status
     $successState = $true # Assume success unless an operation fails
 
-    if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status "Checking HP drivers for $modelName..." }
+    if (-not (Test-Path -Path $DriversFolder -PathType Container)) {
+        WriteLog "Creating Drivers folder: $DriversFolder"
+        New-Item -Path $DriversFolder -ItemType Directory -Force | Out-Null
+    }
+    if (-not (Test-Path -Path $hpDriversBaseFolder -PathType Container)) {
+        WriteLog "Creating HP drivers folder: $hpDriversBaseFolder"
+        New-Item -Path $hpDriversBaseFolder -ItemType Directory -Force | Out-Null
+    }
+    
+    if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status "Checking HP drivers for $displayModelName..." }
     
     try {
         # Check for existing drivers
@@ -146,13 +179,14 @@ function Save-HPDriversTask {
             # Special handling for existing folders that need compression
             if ($CompressToWim -and $existingDriver.Status -eq 'Already downloaded') {
                 $wimFilePath = Join-Path -Path $hpDriversBaseFolder -ChildPath "$($sanitizedModelName).wim"
+                $wimRelativePath = Join-Path -Path $make -ChildPath "$($sanitizedModelName).wim"
                 $sourceFolderPath = Join-Path -Path $hpDriversBaseFolder -ChildPath $sanitizedModelName
                 WriteLog "Attempting compression of existing folder '$sourceFolderPath' to '$wimFilePath'."
                 if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status "Compressing existing..." }
                 try {
-                    Compress-DriverFolderToWim -SourceFolderPath $sourceFolderPath -DestinationWimPath $wimFilePath -WimName $identifier -WimDescription "Drivers for $identifier" -ErrorAction Stop
-                    $existingDriver.Status = "Already downloaded & Compressed"
-                    $existingDriver.DriverPath = Join-Path -Path $make -ChildPath "$($sanitizedModelName).wim"
+                    $null = Compress-DriverFolderToWim -SourceFolderPath $sourceFolderPath -DestinationWimPath $wimFilePath -WimName $identifier -WimDescription "Drivers for $identifier" -PreserveSource:$PreserveSourceOnCompress -ErrorAction Stop
+                    $existingDriver.Status = "Compression successful"
+                    $existingDriver.DriverPath = $wimRelativePath
                     $existingDriver.Success = $true
                     WriteLog "Successfully compressed existing drivers for $identifier to $wimFilePath."
                 }
@@ -187,13 +221,23 @@ function Save-HPDriversTask {
             }
         }
 
-        # Parse PlatformList.xml to find SystemID and OSReleaseID for the specific model
-        WriteLog "Parsing $platformListXml for model '$modelName' details..."
+        # Parse the PlatformList.xml to find the SystemID based on the ProductName
+        WriteLog "Parsing $platformListXml for model '$displayModelName' (SystemID: $systemIdentifier) details..."
         [xml]$platformListContent = Get-Content -Path $platformListXml -Raw -Encoding UTF8 -ErrorAction Stop
-        $platformNode = $platformListContent.ImagePal.Platform | Where-Object { $_.ProductName.'#text' -match "^$([regex]::Escape($modelName))$" } | Select-Object -First 1
+        $platformNode = $null
+        if (-not [string]::IsNullOrWhiteSpace($systemIdentifier)) {
+            $platformNode = $platformListContent.ImagePal.Platform | Where-Object { $_.SystemID -eq $systemIdentifier } | Select-Object -First 1
+            if ($null -eq $platformNode) {
+                WriteLog "SystemID '$systemIdentifier' not found in PlatformList.xml. Falling back to ProductName search."
+            }
+        }
+        if ($null -eq $platformNode) {
+            $searchName = if (-not [string]::IsNullOrWhiteSpace($productName)) { $productName } else { $displayModelName }
+            $platformNode = $platformListContent.ImagePal.Platform | Where-Object { $_.ProductName.'#text' -match "^$([regex]::Escape($searchName))$" } | Select-Object -First 1
+        }
 
         if ($null -eq $platformNode) {
-            throw "Model '$modelName' not found in PlatformList.xml."
+            throw "Model '$displayModelName' (SystemID: $systemIdentifier) not found in PlatformList.xml."
         }
 
         $systemID = $platformNode.SystemID
@@ -286,11 +330,11 @@ function Save-HPDriversTask {
             }
             $availableVersionsString = ($allAvailableVersions | Select-Object -Unique) -join ', '
             if ([string]::IsNullOrWhiteSpace($availableVersionsString)) { $availableVersionsString = "None" }
-            throw "Could not find any suitable OS driver pack for model '$modelName' matching requested or fallback versions (Win$($WindowsRelease) $WindowsVersion). Available: $availableVersionsString"
+            throw "Could not find any suitable OS driver pack for model '$displayModelName' matching requested or fallback versions (Win$($WindowsRelease) $WindowsVersion). Available: $availableVersionsString"
         }
 
         $osReleaseIdFileName = $selectedOSNode.OSReleaseIdFileName -replace 'H', 'h' 
-        WriteLog "Using SystemID: $systemID and OS Info: Win$($selectedOSRelease) ($($selectedOSVersion)) for '$modelName'"
+        WriteLog "Using SystemID: $systemID and OS Info: Win$($selectedOSRelease) ($($selectedOSVersion)) for '$displayModelName'"
         $archSuffix = $WindowsArch -replace "^x", "" 
         $modelRelease = "$($systemID)_$($archSuffix)_$($selectedOSRelease).0.$($selectedOSVersion.ToLower())"
         $driverCabUrl = "https://hpia.hpcloud.hp.com/ref/$systemID/$modelRelease.cab"
@@ -309,7 +353,7 @@ function Save-HPDriversTask {
         $updates = $driverXmlContent.ImagePal.Solutions.UpdateInfo | Where-Object { $_.Category -match '^Driver' }
         $totalDrivers = ($updates | Measure-Object).Count
         $downloadedCount = 0
-        WriteLog "Found $totalDrivers driver updates for $modelName."
+        WriteLog "Found $totalDrivers driver updates for $displayModelName."
         if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status "Found $totalDrivers drivers. Downloading..." }
 
         if (-not (Test-Path -Path $modelSpecificFolder)) {
@@ -327,7 +371,7 @@ function Save-HPDriversTask {
             $extractFolder = Join-Path -Path $downloadFolder -ChildPath ($driverName + "_" + $version + "_" + ($driverFileName -replace '\.exe$', ''))
 
             $downloadedCount++
-            $progressMsg = "($downloadedCount/$totalDrivers) Downloading $driverName..."
+            $progressMsg = "$downloadedCount/$totalDrivers Downloading $driverName"
             if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status $progressMsg }
             WriteLog "$progressMsg URL: $driverUrl"
 
@@ -341,6 +385,8 @@ function Save-HPDriversTask {
             WriteLog "Downloading driver to: $driverFilePath"
             Start-BitsTransferWithRetry -Source $driverUrl -Destination $driverFilePath -ErrorAction Stop
             WriteLog "Driver downloaded: $driverFilePath"
+            $progressMsg = "$downloadedCount/$totalDrivers Extracting $driverName"
+            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status $progressMsg }
             WriteLog "Creating extraction folder: $extractFolder"
             New-Item -Path $extractFolder -ItemType Directory -Force -ErrorAction Stop | Out-Null
             $arguments = "/s /e /f `"$extractFolder`"" 
@@ -354,7 +400,7 @@ function Save-HPDriversTask {
         }
 
         Remove-Item -Path $driverCabFile, $driverXmlFile -Force -ErrorAction SilentlyContinue
-        WriteLog "Cleaned up driver cab and xml files for $modelName"
+        WriteLog "Cleaned up driver cab and xml files for $displayModelName"
         
         $finalStatus = "Completed" 
         if ($CompressToWim) {
@@ -362,7 +408,7 @@ function Save-HPDriversTask {
             $wimFilePath = Join-Path -Path $hpDriversBaseFolder -ChildPath "$($identifier).wim"
             WriteLog "Compressing '$modelSpecificFolder' to '$wimFilePath'..."
             try {
-                Compress-DriverFolderToWim -SourceFolderPath $modelSpecificFolder -DestinationWimPath $wimFilePath -WimName $identifier -WimDescription "Drivers for $identifier" -ErrorAction Stop
+                $null = Compress-DriverFolderToWim -SourceFolderPath $modelSpecificFolder -DestinationWimPath $wimFilePath -WimName $identifier -WimDescription "Drivers for $identifier" -PreserveSource:$PreserveSourceOnCompress -ErrorAction Stop
                 WriteLog "Compression successful for '$identifier'."
                 $finalStatus = "Completed & Compressed"
                 $driverRelativePath = Join-Path -Path $make -ChildPath "$($identifier).wim" # Update relative path to the WIM
@@ -375,15 +421,12 @@ function Save-HPDriversTask {
         $successState = $true
     }
     catch {
-        $errorMessage = "Error saving HP drivers for $($modelName): $($_.Exception.Message)"
+        $errorMessage = "Error saving HP drivers for $($displayModelName): $($_.Exception.Message)"
         WriteLog $errorMessage
         $finalStatus = "Error: $($_.Exception.Message.Split([Environment]::NewLine)[0])"
         $successState = $false
         $driverRelativePath = $null # Ensure path is null on error
-        if (Test-Path -Path $modelSpecificFolder -PathType Container) {
-            WriteLog "Attempting to remove partially created folder $modelSpecificFolder due to error."
-            Remove-Item -Path $modelSpecificFolder -Recurse -Force -ErrorAction SilentlyContinue
-        }
+        Remove-DriverModelFolder -DriversFolder $DriversFolder -TargetFolder $modelSpecificFolder -Description $identifier
     }
             
     if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status $finalStatus }

FFUDevelopment/FFUUI.Core/FFUUI.Core.Drivers.Lenovo.psm1

@@ -94,17 +94,20 @@ function Save-LenovoDriversTask {
         [hashtable]$Headers,
         [Parameter(Mandatory = $true)]
         [string]$UserAgent,
-        [Parameter()] # Made optional
+        [Parameter()]
         [System.Collections.Concurrent.ConcurrentQueue[hashtable]]$ProgressQueue = $null,
         [Parameter()]
-        [bool]$CompressToWim = $false
+        [bool]$CompressToWim = $false,
+        [Parameter()]
+        [bool]$PreserveSourceOnCompress = $false
     )
             
     # The Model property from the UI already contains the combined "ProductName (MachineType)" string
     $identifier = $DriverItemData.Model
     $machineType = $DriverItemData.MachineType 
     $make = "Lenovo"
-    $sanitizedIdentifier = $identifier -replace '[\\/:"*?<>|]', '_'
+    $sanitizedIdentifier = ConvertTo-SafeName -Name $identifier
+    if ($sanitizedIdentifier -ne $identifier) { WriteLog "Sanitized model identifier: '$identifier' -> '$sanitizedIdentifier'" }
     $status = "Starting..."
     $success = $false
     
@@ -129,13 +132,14 @@ function Save-LenovoDriversTask {
             # Special handling for existing folders that need compression
             if ($CompressToWim -and $existingDriver.Status -eq 'Already downloaded') {
                 $wimFilePath = Join-Path -Path $makeDriversPath -ChildPath "$($sanitizedIdentifier).wim"
+                $wimRelativePath = Join-Path -Path $make -ChildPath "$($sanitizedIdentifier).wim"
                 $sourceFolderPath = Join-Path -Path $makeDriversPath -ChildPath $sanitizedIdentifier
                 WriteLog "Attempting compression of existing folder '$sourceFolderPath' to '$wimFilePath'."
                 if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status "Compressing existing..." }
                 try {
-                    Compress-DriverFolderToWim -SourceFolderPath $sourceFolderPath -DestinationWimPath $wimFilePath -WimName $identifier -WimDescription "Drivers for $identifier" -ErrorAction Stop
-                    $existingDriver.Status = "Already downloaded & Compressed"
-                    $existingDriver.DriverPath = Join-Path -Path $make -ChildPath "$($sanitizedIdentifier).wim"
+                    $null = Compress-DriverFolderToWim -SourceFolderPath $sourceFolderPath -DestinationWimPath $wimFilePath -WimName $identifier -WimDescription "Drivers for $identifier" -PreserveSource:$PreserveSourceOnCompress -ErrorAction Stop
+                    $existingDriver.Status = "Compression successful"
+                    $existingDriver.DriverPath = $wimRelativePath
                     $existingDriver.Success = $true
                     WriteLog "Successfully compressed existing drivers for $identifier to $wimFilePath."
                 }
@@ -204,17 +208,16 @@ function Save-LenovoDriversTask {
             $packageXMLPath = Join-Path -Path $tempDownloadPath -ChildPath $packageName
             $baseURL = $packageUrl -replace [regex]::Escape($packageName), "" # Base URL for the driver file
 
-            $status = "($processedPackages/$totalPackages) Getting package info..."
-            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status $status }
-
             # Download the package XML
             WriteLog "($processedPackages/$totalPackages) Downloading package XML: $packageUrl"
             try {
                 Start-BitsTransferWithRetry -Source $packageUrl -Destination $packageXMLPath
             }
             catch {
-                WriteLog "($processedPackages/$totalPackages) Failed to download package XML '$packageUrl'. Skipping. Error: $($_.Exception.Message)"
-                continue # Skip this package
+                $failureMessage = "Failed to download Lenovo package XML '$packageUrl': $($_.Exception.Message)"
+                WriteLog "($processedPackages/$totalPackages) $failureMessage"
+                Remove-Item -Path $packageXMLPath -Force -ErrorAction SilentlyContinue
+                throw (New-Object System.Exception($failureMessage, $_.Exception))
             }
 
             # Load and parse the package XML
@@ -275,7 +278,7 @@ function Save-LenovoDriversTask {
             }
 
             # Download the driver .exe
-            $status = "($processedPackages/$totalPackages) Downloading $packageTitle..."
+            $status = "$processedPackages/$totalPackages Downloading $packageTitle"
             if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status $status }
             WriteLog "($processedPackages/$totalPackages) Downloading driver: $driverUrl to $driverFilePath"
             try {
@@ -283,13 +286,14 @@ function Save-LenovoDriversTask {
                 WriteLog "($processedPackages/$totalPackages) Driver downloaded: $driverFileName"
             }
             catch {
-                WriteLog "($processedPackages/$totalPackages) Failed to download driver '$driverUrl'. Skipping. Error: $($_.Exception.Message)"
-                Remove-Item -Path $packageXMLPath -Force -ErrorAction SilentlyContinue # Clean up package XML
-                continue # Skip this driver
+                $failureMessage = "Failed to download driver '$packageTitle' from $($driverUrl): $($_.Exception.Message)"
+                WriteLog "($processedPackages/$totalPackages) $failureMessage"
+                Remove-Item -Path $packageXMLPath -Force -ErrorAction SilentlyContinue
+                throw (New-Object System.Exception($failureMessage, $_.Exception))
             }
 
             # --- Extraction Logic ---
-            $status = "($processedPackages/$totalPackages) Extracting $packageTitle..."
+            $status = "$processedPackages/$totalPackages Extracting $packageTitle"
             if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status $status }
     
             # Always use a temporary extraction path to avoid long path issues
@@ -314,7 +318,7 @@ function Save-LenovoDriversTask {
     
             # Modify the extract command to point to the temporary folder
             $modifiedExtractCommand = $extractCommand -replace '%PACKAGEPATH%', "`"$extractFolder`""
-            WriteLog "($processedPackages/$totalPackages) Extracting driver: $driverFilePath using command: $modifiedExtractCommand"
+            WriteLog "$processedPackages/$totalPackages Extracting driver: $driverFilePath using command: $modifiedExtractCommand"
                 
             try {
                 Invoke-Process -FilePath $driverFilePath -ArgumentList $modifiedExtractCommand -Wait $true | Out-Null
@@ -322,14 +326,13 @@ function Save-LenovoDriversTask {
                 $extractionSucceeded = $true
             }
             catch {
-                WriteLog "($processedPackages/$totalPackages) Failed to extract driver '$driverFilePath' to temporary path. Skipping. Error: $($_.Exception.Message)"
-                # Don't delete the downloaded exe yet if extraction fails
-                Remove-Item -Path $packageXMLPath -Force -ErrorAction SilentlyContinue # Clean up package XML
-                # Clean up temp folder if extraction failed
+                $failureMessage = "Failed to extract driver package '$packageTitle': $($_.Exception.Message)"
+                WriteLog "($processedPackages/$totalPackages) $failureMessage"
+                Remove-Item -Path $packageXMLPath -Force -ErrorAction SilentlyContinue
                 if ($tempExtractBase -and (Test-Path -Path $tempExtractBase)) {
                     Remove-Item -Path $tempExtractBase -Recurse -Force -ErrorAction SilentlyContinue
                 }
-                continue # Skip further processing for this driver
+                throw (New-Object System.Exception($failureMessage, $_.Exception))
             }
     
             # --- Post-Extraction Handling (Move from Temp to Final Destination) ---
@@ -372,10 +375,9 @@ function Save-LenovoDriversTask {
                             Move-Item -Path $item.FullName -Destination $finalDestinationPath -Force -ErrorAction Stop
                         }
                         catch {
-                            WriteLog "($processedPackages/$totalPackages) Failed to move item '$($item.FullName)' to '$finalDestinationPath'. Error: $($_.Exception.Message)"
-                            # Decide if this should stop the whole process or just skip this item
-                            # For now, we'll log and continue, but mark overall success as false
-                            $extractionSucceeded = $false
+                            $failureMessage = "Failed to move extracted item '$($item.FullName)' to '$finalDestinationPath': $($_.Exception.Message)"
+                            WriteLog "($processedPackages/$totalPackages) $failureMessage"
+                            throw (New-Object System.Exception($failureMessage, $_.Exception))
                         }
                     } # End foreach ($item in $extractedItems)
     
@@ -412,6 +414,9 @@ function Save-LenovoDriversTask {
             # Always delete the package XML
             WriteLog "($processedPackages/$totalPackages) Deleting package XML file: $packageXMLPath"
             Remove-Item -Path $packageXMLPath -Force -ErrorAction SilentlyContinue
+            if (-not $extractionSucceeded) {
+                throw (New-Object System.Exception("Failed to extract driver '$packageTitle'. See log for details."))
+            }
     
         } # End foreach package
         
@@ -424,7 +429,7 @@ function Save-LenovoDriversTask {
             $driverRelativePath = Join-Path -Path $make -ChildPath $wimFileName # Update relative path to the WIM file
             WriteLog "Compressing '$modelPath' to '$destinationWimPath'..."
             try {
-                $compressResult = Compress-DriverFolderToWim -SourceFolderPath $modelPath -DestinationWimPath $destinationWimPath -WimName $identifier -WimDescription $identifier -ErrorAction Stop
+                $compressResult = Compress-DriverFolderToWim -SourceFolderPath $modelPath -DestinationWimPath $destinationWimPath -WimName $identifier -WimDescription $identifier -PreserveSource:$PreserveSourceOnCompress -ErrorAction Stop
                 if ($compressResult) {
                     WriteLog "Compression successful for '$identifier'."
                     $status = "Completed & Compressed"
@@ -448,12 +453,11 @@ function Save-LenovoDriversTask {
         
     }
     catch {
-        $status = "Error: $($_.Exception.Message.Split('.')[0])" # Shorten error message
-        WriteLog "Error saving Lenovo drivers for '$identifier': $($_.Exception.ToString())" # Log full exception string
+        $status = "Error: $($_.Exception.Message)"
+        WriteLog "Error saving Lenovo drivers for '$identifier': $($_.Exception.ToString())"
         $success = $false
-        # Enqueue the error status before returning
+        Remove-DriverModelFolder -DriversFolder $DriversFolder -TargetFolder $modelPath -Description $identifier
         if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status $status }
-        # Ensure return object is created even on error
         return [PSCustomObject]@{ Identifier = $identifier; Status = $status; Success = $success; DriverPath = $null }
     }
     finally {

FFUDevelopment/FFUUI.Core/FFUUI.Core.Drivers.Microsoft.psm1

@@ -10,12 +10,33 @@ function Get-MicrosoftDriversModelList {
     [CmdletBinding()]
     param(
         [hashtable]$Headers, # Pass necessary headers
-        [string]$UserAgent # Pass UserAgent
+        [string]$UserAgent, # Pass UserAgent
+        [Parameter(Mandatory = $true)]
+        [string]$DriversFolder
     )
 
     $url = "https://support.microsoft.com/en-us/surface/download-drivers-and-firmware-for-surface-09bb2e09-2a4b-cb69-0951-078a7739e120"
     $models = @()
 
+    # Load cached model list first (Source B) to keep the UI fast.
+    # The cache is refreshed automatically when missing or invalid.
+    try {
+        $cachePath = Get-SurfaceDriverIndexCachePath -DriversFolder $DriversFolder
+        if (Test-Path -Path $cachePath -PathType Leaf) {
+            $cacheAgeDays = ((Get-Date) - (Get-Item -Path $cachePath).LastWriteTime).TotalDays
+            if ($cacheAgeDays -lt 7) {
+                $cache = Import-SurfaceDriverIndexCache -DriversFolder $DriversFolder
+                if ($cache.ModelIndex -and $cache.ModelIndex.Count -gt 0) {
+                    WriteLog "Surface cache: Using cached Microsoft model list ($($cache.ModelIndex.Count) models)."
+                    return @($cache.ModelIndex)
+                }
+            }
+        }
+    }
+    catch {
+        WriteLog "Surface cache: Failed to load cached Microsoft model list. Falling back to online parse. Error: $($_.Exception.Message)"
+    }
+
     try {
         WriteLog "Getting Surface driver information from $url"
         $OriginalVerbosePreference = $VerbosePreference
@@ -70,6 +91,18 @@ function Get-MicrosoftDriversModelList {
             }
         }
         WriteLog "Parsing complete. Found $($models.Count) models."
+
+        # Persist model list (Source B) into the local cache for fast UI population.
+        try {
+            $cache = Import-SurfaceDriverIndexCache -DriversFolder $DriversFolder
+            $cache.ModelIndex = @($models)
+            Save-SurfaceDriverIndexCache -Cache $cache -DriversFolder $DriversFolder
+            WriteLog "Surface cache: Saved Microsoft model list to cache."
+        }
+        catch {
+            WriteLog "Surface cache: Failed to save Microsoft model list. Error: $($_.Exception.Message)"
+        }
+
         return $models
     }
     catch {
@@ -94,7 +127,9 @@ function Save-MicrosoftDriversTask {
         [Parameter()] # Made optional
         [System.Collections.Concurrent.ConcurrentQueue[hashtable]]$ProgressQueue = $null, # Default to null
         [Parameter()]
-        [bool]$CompressToWim = $false # New parameter for compression
+        [bool]$CompressToWim = $false, # New parameter for compression
+        [Parameter()]
+        [bool]$PreserveSourceOnCompress = $false
         # REMOVED: UI-related parameters
     )
         
@@ -104,6 +139,10 @@ function Save-MicrosoftDriversTask {
     $driverRelativePath = Join-Path -Path $make -ChildPath $modelName # Relative path for the driver folder
     $status = "Getting download link..." # Initial local status
     $success = $false
+    $sanitizedModelName = ConvertTo-SafeName -Name $modelName
+    if ($sanitizedModelName -ne $modelName) { WriteLog "Sanitized model name: '$modelName' -> '$sanitizedModelName'" }
+    $makeDriversPath = Join-Path -Path $DriversFolder -ChildPath $make
+    $modelPath = Join-Path -Path $makeDriversPath -ChildPath $sanitizedModelName
     
     # Initial status update
     if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status "Checking..." }
@@ -121,13 +160,14 @@ function Save-MicrosoftDriversTask {
             if ($CompressToWim -and $existingDriver.Status -eq 'Already downloaded') {
                 $makeDriversPath = Join-Path -Path $DriversFolder -ChildPath $make
                 $wimFilePath = Join-Path -Path $makeDriversPath -ChildPath "$($modelName).wim"
+                $wimRelativePath = Join-Path -Path $make -ChildPath "$($modelName).wim"
                 $sourceFolderPath = Join-Path -Path $makeDriversPath -ChildPath $modelName
                 WriteLog "Attempting compression of existing folder '$sourceFolderPath' to '$wimFilePath'."
                 if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status "Compressing existing..." }
                 try {
-                    Compress-DriverFolderToWim -SourceFolderPath $sourceFolderPath -DestinationWimPath $wimFilePath -WimName $modelName -WimDescription "Drivers for $modelName" -ErrorAction Stop
-                    $existingDriver.Status = "Already downloaded & Compressed"
-                    $existingDriver.DriverPath = Join-Path -Path $make -ChildPath "$($modelName).wim"
+                    $null = Compress-DriverFolderToWim -SourceFolderPath $sourceFolderPath -DestinationWimPath $wimFilePath -WimName $modelName -WimDescription "Drivers for $modelName" -PreserveSource:$PreserveSourceOnCompress -ErrorAction Stop
+                    $existingDriver.Status = "Compression successful"
+                    $existingDriver.DriverPath = $wimRelativePath
                     $existingDriver.Success = $true
                     WriteLog "Successfully compressed existing drivers for $modelName to $wimFilePath."
                 }
@@ -145,49 +185,123 @@ function Save-MicrosoftDriversTask {
         ### GET THE DOWNLOAD LINK
         $status = "Getting download link..."
         if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
-        WriteLog "Getting download page content for $modelName from $modelLink"
-        $OriginalVerbosePreference = $VerbosePreference
-        $VerbosePreference = 'SilentlyContinue'
-        # Use passed-in UserAgent and Headers
-        $downloadPageContent = Invoke-WebRequest -Uri $modelLink -UseBasicParsing -Headers $Headers -UserAgent $UserAgent
-        $VerbosePreference = $OriginalVerbosePreference
-        WriteLog "Complete"
 
-        $status = "Parsing download page..."
-        if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
-        WriteLog "Parsing download page for file"
-        $scriptPattern = '<script>window.__DLCDetails__={(.*?)}<\/script>'
-        $scriptMatch = [regex]::Match($downloadPageContent.Content, $scriptPattern)
+        # Initialize Win10/Win11 link variables
+        $win10Link = $null
+        $win10FileName = $null
+        $win11Link = $null
+        $win11FileName = $null
 
-        if ($scriptMatch.Success) {
-            $scriptContent = $scriptMatch.Groups[1].Value
-            # $downloadFilePattern = '"name":"(.*?)",.*?"url":"(.*?)"'
-            $downloadFilePattern = '"name":"([^"]+\.(?:msi|zip))",[^}]*?"url":"(.*?)"'
-            $downloadFileMatches = [regex]::Matches($scriptContent, $downloadFilePattern, [System.Text.RegularExpressions.RegexOptions]::IgnoreCase)
+        # Prefer cached Download Center details (Source C) to avoid unnecessary internet calls and cache rewrites
+        $useCachedDownloadCenterDetails = $false
+        try {
+            $cache = Import-SurfaceDriverIndexCache -DriversFolder $DriversFolder
+            $cachedDetails = @($cache.DownloadCenterDetails | Where-Object { $_.Link -eq $modelLink } | Select-Object -First 1)
+            if ($cachedDetails.Count -gt 0 -and $cachedDetails[0].Files -and $cachedDetails[0].Files.Count -gt 0) {
+                $useCachedDownloadCenterDetails = $true
+                WriteLog "Surface cache: Using cached Download Center details for $modelName from $modelLink"
 
+                foreach ($downloadFile in @($cachedDetails[0].Files)) {
+                    if ($null -eq $downloadFile) { continue }
+                    $currentFileName = $downloadFile.Name
+                    $fileUrl = $downloadFile.Url
+                    if ([string]::IsNullOrWhiteSpace($currentFileName) -or [string]::IsNullOrWhiteSpace($fileUrl)) { continue }
 
-            $win10Link = $null
-            $win10FileName = $null
-            $win11Link = $null
-            $win11FileName = $null
-
-            # Iterate through all matches to find potential Win10 and Win11 links
-            foreach ($downloadFile in $downloadFileMatches) {
-                $currentFileName = $downloadFile.Groups[1].Value
-                $fileUrl = $downloadFile.Groups[2].Value
-
-                if ($currentFileName -match "Win10") {
-                    $win10Link = $fileUrl
-                    $win10FileName = $currentFileName
-                    WriteLog "Found Win10 link: $win10FileName"
-                }
-                elseif ($currentFileName -match "Win11") {
-                    $win11Link = $fileUrl
-                    $win11FileName = $currentFileName
-                    WriteLog "Found Win11 link: $win11FileName"
+                    if ($currentFileName -match "Win10") {
+                        $win10Link = $fileUrl
+                        $win10FileName = $currentFileName
+                        WriteLog "Found Win10 link (cached): $win10FileName"
+                    }
+                    elseif ($currentFileName -match "Win11") {
+                        $win11Link = $fileUrl
+                        $win11FileName = $currentFileName
+                        WriteLog "Found Win11 link (cached): $win11FileName"
+                    }
                 }
             }
+        }
+        catch {
+            WriteLog "Surface cache: Failed loading cached Download Center details for '$modelName'. Error: $($_.Exception.Message)"
+        }
 
+        # Cache miss: download and parse the model's Download Center page (Source C), then backfill the cache
+        if (-not $useCachedDownloadCenterDetails) {
+            WriteLog "Getting download page content for $modelName from $modelLink"
+            $OriginalVerbosePreference = $VerbosePreference
+            $VerbosePreference = 'SilentlyContinue'
+            # Use passed-in UserAgent and Headers
+            $downloadPageContent = Invoke-WebRequest -Uri $modelLink -UseBasicParsing -Headers $Headers -UserAgent $UserAgent
+            $VerbosePreference = $OriginalVerbosePreference
+            WriteLog "Complete"
+
+            $status = "Parsing download page..."
+            if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
+            WriteLog "Parsing download page for file"
+            $scriptPattern = '<script>window.__DLCDetails__={(.*?)}<\/script>'
+            $scriptMatch = [regex]::Match($downloadPageContent.Content, $scriptPattern)
+
+            if ($scriptMatch.Success) {
+                $scriptContent = $scriptMatch.Groups[1].Value
+                # $downloadFilePattern = '"name":"(.*?)",.*?"url":"(.*?)"'
+                $downloadFilePattern = '"name":"([^"]+\.(?:msi|zip))",[^}]*?"url":"(.*?)"'
+                $downloadFileMatches = [regex]::Matches($scriptContent, $downloadFilePattern, [System.Text.RegularExpressions.RegexOptions]::IgnoreCase)
+
+                # Iterate through all matches to find potential Win10 and Win11 links
+                foreach ($downloadFile in $downloadFileMatches) {
+                    $currentFileName = $downloadFile.Groups[1].Value
+                    $fileUrl = $downloadFile.Groups[2].Value
+
+                    if ($currentFileName -match "Win10") {
+                        $win10Link = $fileUrl
+                        $win10FileName = $currentFileName
+                        WriteLog "Found Win10 link: $win10FileName"
+                    }
+                    elseif ($currentFileName -match "Win11") {
+                        $win11Link = $fileUrl
+                        $win11FileName = $currentFileName
+                        WriteLog "Found Win11 link: $win11FileName"
+                    }
+                }
+
+                # Update local cache with Download Center file details (Source C) for this model.
+                # This runs during download (not during Get Models) so it won't slow the listview population.
+                try {
+                    $filesForCache = [System.Collections.Generic.List[pscustomobject]]::new()
+                    if ($win10Link -and $win10FileName) {
+                        $filesForCache.Add([pscustomobject]@{ Name = $win10FileName; Url = $win10Link })
+                    }
+                    if ($win11Link -and $win11FileName) {
+                        $filesForCache.Add([pscustomobject]@{ Name = $win11FileName; Url = $win11Link })
+                    }
+
+                    if ($filesForCache.Count -gt 0) {
+                        $cache = Import-SurfaceDriverIndexCache -DriversFolder $DriversFolder
+                        $detailsEntry = [pscustomobject][ordered]@{
+                            Model = $modelName
+                            Link  = $modelLink
+                            Files = @($filesForCache)
+                        }
+
+                        $newDetails = [System.Collections.Generic.List[pscustomobject]]::new()
+                        foreach ($item in @($cache.DownloadCenterDetails)) {
+                            if ($null -ne $item -and $item.PSObject.Properties['Link'] -and $item.Link -ne $modelLink) {
+                                $newDetails.Add($item)
+                            }
+                        }
+                        $newDetails.Add($detailsEntry)
+                        $cache.DownloadCenterDetails = @($newDetails)
+                        Save-SurfaceDriverIndexCache -Cache $cache -DriversFolder $DriversFolder
+                    }
+                }
+                catch {
+                    WriteLog "Surface cache: Failed updating Download Center details cache for '$modelName'. Error: $($_.Exception.Message)"
+                }
+
+                $useCachedDownloadCenterDetails = $true
+            }
+        }
+
+        if ($useCachedDownloadCenterDetails) {
             # Decision logic to select the appropriate download link
             $downloadLink = $null
             $fileName = $null
@@ -224,7 +338,7 @@ function Save-MicrosoftDriversTask {
             ### DOWNLOAD AND EXTRACT
             if ($downloadLink) {
                 WriteLog "Selected Download Link for $modelName (Actual: Windows $downloadedVersion): $downloadLink"
-                $status = "Downloading (Win$downloadedVersion)..." # Update status message
+                $status = "Downloading Win$downloadedVersion $fileName"
                 if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
 
                 # Create directories
@@ -232,8 +346,6 @@ function Save-MicrosoftDriversTask {
                     WriteLog "Creating Drivers folder: $DriversFolder"
                     New-Item -Path $DriversFolder -ItemType Directory -Force | Out-Null
                 }
-                $makeDriversPath = Join-Path -Path $DriversFolder -ChildPath $Make
-                $modelPath = Join-Path -Path $makeDriversPath -ChildPath $modelName
                 if (-Not (Test-Path -Path $modelPath)) {
                     WriteLog "Creating model folder: $modelPath"
                     New-Item -Path $modelPath -ItemType Directory -Force | Out-Null
@@ -253,7 +365,7 @@ function Save-MicrosoftDriversTask {
 
                 ### EXTRACT
                 if ($fileExtension -eq ".msi") {
-                    $status = "Waiting for MSI lock..." # Set initial status
+                    $status = "Waiting for MSI lock..."
                     if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
 
                     # Use a named mutex to ensure only one MSI extraction happens at a time across all parallel tasks
@@ -282,14 +394,14 @@ function Save-MicrosoftDriversTask {
                             catch [System.Threading.WaitHandleCannotBeOpenedException] {
                                 # Mutex is clear, proceed to extraction attempt
                                 WriteLog "System MSI mutex clear. Proceeding with MSI extraction attempt for $modelName."
-                                $status = "Extracting MSI..."
+                                $status = "Extracting Win$downloadedVersion $fileName"
                                 if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
                                 $mutexClear = $true
                             }
                             catch {
                                 # Handle other potential errors when checking the mutex
                                 WriteLog "Warning: Error checking system MSI mutex for $($modelName): $_. Proceeding with caution."
-                                $status = "Extracting MSI (Mutex Error)..."
+                                $status = "Extracting Win$downloadedVersion $fileName (Mutex Error)"
                                 if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
                                 $mutexClear = $true # Proceed despite mutex error
                             }
@@ -347,7 +459,7 @@ function Save-MicrosoftDriversTask {
                     }
                 }
                 elseif ($fileExtension -eq ".zip") {
-                    $status = "Extracting ZIP..." # Set status before extraction
+                    $status = "Extracting Win$downloadedVersion $fileName"
                     if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
                     WriteLog "Extracting ZIP file to $modelPath"
                     $ProgressPreference = 'SilentlyContinue'
@@ -377,7 +489,7 @@ function Save-MicrosoftDriversTask {
                     WriteLog "Compressing '$modelPath' to '$destinationWimPath'..."
                     try {
                         # Use the function from the imported common module
-                        $compressResult = Compress-DriverFolderToWim -SourceFolderPath $modelPath -DestinationWimPath $destinationWimPath -WimName $modelName -WimDescription $modelName -ErrorAction Stop
+                        $compressResult = Compress-DriverFolderToWim -SourceFolderPath $modelPath -DestinationWimPath $destinationWimPath -WimName $modelName -WimDescription $modelName -PreserveSource:$PreserveSourceOnCompress -ErrorAction Stop
                         if ($compressResult) {
                             WriteLog "Compression successful for '$modelName'."
                             $status = "Completed & Compressed"
@@ -417,6 +529,7 @@ function Save-MicrosoftDriversTask {
         $status = "Error: $($_.Exception.Message.Split('.')[0])" # Shorten error message
         WriteLog "Error saving Microsoft drivers for $($modelName): $($_.Exception.Message)"
         $success = $false
+        Remove-DriverModelFolder -DriversFolder $DriversFolder -TargetFolder $modelPath -Description $modelName
         # Enqueue the error status before returning
         if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $modelName -Status $status }
         # Ensure return object is created even on error

FFUDevelopment/FFUUI.Core/FFUUI.Core.Drivers.psm1

@@ -5,8 +5,173 @@
     This module contains all the business logic for the 'Drivers' tab in the FFU Builder UI. It handles fetching driver model lists from various manufacturers (Microsoft, Dell, HP, Lenovo), displaying and filtering them in the UI, and managing the selection state. It also includes functions to import and export driver selections to a JSON file (Drivers.json) and to orchestrate the parallel download of selected driver packages using the common parallel processing module.
 #>
 
-# Helper function to get models for a selected Make and standardize them
-function Get-ModelsForMake {
+function ConvertTo-DriverBaseName {
+    param(
+        [string]$ModelString
+    )
+
+    if ([string]::IsNullOrWhiteSpace($ModelString)) {
+        return $ModelString
+    }
+
+    if ($ModelString -match '^(.*?)\s*\((.+)\)\s*$') {
+        return $matches[1].Trim()
+    }
+
+    return $ModelString.Trim()
+}
+
+function Get-DriverDisplayName {
+    param(
+        [string]$BaseName,
+        [string]$Identifier
+    )
+
+    if ([string]::IsNullOrWhiteSpace($BaseName)) {
+        return $Identifier
+    }
+
+    if ([string]::IsNullOrWhiteSpace($Identifier)) {
+        return $BaseName.Trim()
+    }
+
+        return "$($BaseName.Trim()) ($($Identifier.Trim()))"
+    }
+    
+    function Get-EffectiveDriverWindowsRelease {
+        param(
+            [Parameter(Mandatory = $true)]
+            [int]$WindowsRelease,
+            [string]$WindowsReleaseDisplay,
+            [string]$WindowsSku
+        )
+    
+        # Normalize LTSC/LTSB UI release selections to client driver releases for OEM catalogs.
+        if (-not [string]::IsNullOrWhiteSpace($WindowsReleaseDisplay)) {
+            if (($WindowsReleaseDisplay -like 'Windows 10*') -and (($WindowsReleaseDisplay -like '*LTSB*') -or ($WindowsReleaseDisplay -like '*LTSC*'))) {
+                return 10
+            }
+            if (($WindowsReleaseDisplay -like 'Windows 11*') -and ($WindowsReleaseDisplay -like '*LTSC*')) {
+                return 11
+            }
+        }
+    
+        # Use SKU-based fallback when display text is unavailable.
+        if (-not [string]::IsNullOrWhiteSpace($WindowsSku) -and $WindowsSku -like '*LTS*') {
+            if ($WindowsRelease -in 2016, 2019, 2021) {
+                return 10
+            }
+            if ($WindowsRelease -eq 2024) {
+                return 11
+            }
+        }
+    
+        return $WindowsRelease
+    }
+    
+    function Convert-DriverItemToJsonModel {
+    param(
+        [Parameter(Mandatory = $true)]
+        [pscustomobject]$DriverItem
+    )
+
+    $makeName = $DriverItem.Make
+    switch ($makeName) {
+        'Microsoft' {
+            $modelObject = @{ Name = $DriverItem.Model }
+            if ($DriverItem.PSObject.Properties['Link'] -and -not [string]::IsNullOrWhiteSpace($DriverItem.Link)) {
+                $modelObject.Link = $DriverItem.Link
+            }
+            return $modelObject
+        }
+        'Dell' {
+            $systemId = if ($DriverItem.PSObject.Properties['SystemId']) { $DriverItem.SystemId } else { $null }
+            $baseName = ConvertTo-DriverBaseName -ModelString $DriverItem.Model
+            if ([string]::IsNullOrWhiteSpace($baseName)) {
+                $baseName = $DriverItem.Model
+            }
+            $modelObject = @{ Name = $baseName }
+            if (-not [string]::IsNullOrWhiteSpace($systemId)) {
+                $modelObject.SystemId = $systemId
+            }
+            if ($DriverItem.PSObject.Properties['CabUrl'] -and -not [string]::IsNullOrWhiteSpace($DriverItem.CabUrl)) {
+                $modelObject.CabUrl = $DriverItem.CabUrl
+            }
+            return $modelObject
+        }
+        'HP' {
+            $baseName = if ($DriverItem.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($DriverItem.ProductName)) { $DriverItem.ProductName } else { ConvertTo-DriverBaseName -ModelString $DriverItem.Model }
+            if ([string]::IsNullOrWhiteSpace($baseName)) {
+                $baseName = $DriverItem.Model
+            }
+            $systemId = if ($DriverItem.PSObject.Properties['SystemId']) { $DriverItem.SystemId } else { $null }
+            $modelObject = @{ Name = $baseName.Trim() }
+            if (-not [string]::IsNullOrWhiteSpace($systemId)) {
+                $modelObject.SystemId = $systemId
+            }
+            return $modelObject
+        }
+        'Lenovo' {
+            $machineType = $DriverItem.MachineType
+            $baseName = if ($DriverItem.ProductName) { $DriverItem.ProductName } else { ConvertTo-DriverBaseName -ModelString $DriverItem.Model }
+            if ([string]::IsNullOrWhiteSpace($baseName) -or [string]::IsNullOrWhiteSpace($machineType)) {
+                WriteLog "Skipping Lenovo driver '$($DriverItem.Model)' because Name or MachineType is missing."
+                return $null
+            }
+            return @{
+                Name        = $baseName
+                MachineType = $machineType
+            }
+        }
+                default {
+                    WriteLog "Convert-DriverItemToJsonModel: Unsupported Make '$makeName'."
+                    return $null
+                }
+            }
+        }
+        
+        function Remove-DriverModelFolder {
+            param(
+                [Parameter(Mandatory = $true)]
+                [string]$DriversFolder,
+                [Parameter(Mandatory = $true)]
+                [string]$TargetFolder,
+                [string]$Description
+            )
+        
+            if ([string]::IsNullOrWhiteSpace($DriversFolder) -or [string]::IsNullOrWhiteSpace($TargetFolder)) {
+                return
+            }
+        
+            try {
+                if (-not (Test-Path -Path $TargetFolder -PathType Container)) {
+                    return
+                }
+        
+                $driversRoot = [System.IO.Path]::GetFullPath((Resolve-Path -Path $DriversFolder -ErrorAction Stop).ProviderPath)
+                $targetPath = [System.IO.Path]::GetFullPath((Resolve-Path -Path $TargetFolder -ErrorAction Stop).ProviderPath)
+        
+                if ($targetPath -eq $driversRoot) {
+                    WriteLog "Remove-DriverModelFolder skipped deleting Drivers root: $targetPath"
+                    return
+                }
+        
+                if (-not ($targetPath.StartsWith($driversRoot, [System.StringComparison]::OrdinalIgnoreCase))) {
+                    WriteLog "Remove-DriverModelFolder skipped path outside Drivers root: $targetPath"
+                    return
+                }
+        
+                $contextMessage = if ([string]::IsNullOrWhiteSpace($Description)) { $targetPath } else { "$Description ($targetPath)" }
+                WriteLog "Removing driver folder $contextMessage due to failure."
+                Remove-Item -Path $targetPath -Recurse -Force -ErrorAction SilentlyContinue
+            }
+            catch {
+                WriteLog "Remove-DriverModelFolder failed for $($TargetFolder): $($_.Exception.Message)"
+            }
+        }
+        
+        # Helper function to get models for a selected Make and standardize them
+        function Get-ModelsForMake {
     param(
         [Parameter(Mandatory = $true)]
         [string]$SelectedMake,
@@ -20,8 +185,20 @@ function Get-ModelsForMake {
     # Get necessary values from UI or script scope
     $localDriversFolder = $State.Controls.txtDriversFolder.Text
     $localWindowsRelease = $null
+    $localWindowsReleaseDisplay = $null
     if ($null -ne $State.Controls.cmbWindowsRelease.SelectedItem) {
         $localWindowsRelease = $State.Controls.cmbWindowsRelease.SelectedItem.Value
+        $localWindowsReleaseDisplay = $State.Controls.cmbWindowsRelease.SelectedItem.Display
+    }
+
+    # Resolve effective release used specifically for OEM driver operations.
+    $localWindowsSku = if ($null -ne $State.Controls.cmbWindowsSKU.SelectedItem) { [string]$State.Controls.cmbWindowsSKU.SelectedItem } else { $null }
+    $localDriverWindowsRelease = $localWindowsRelease
+    if ($null -ne $localWindowsRelease) {
+        $localDriverWindowsRelease = Get-EffectiveDriverWindowsRelease -WindowsRelease $localWindowsRelease -WindowsReleaseDisplay $localWindowsReleaseDisplay -WindowsSku $localWindowsSku
+        if ($localDriverWindowsRelease -ne $localWindowsRelease) {
+            WriteLog "Normalized WindowsRelease for model retrieval from $localWindowsRelease to $localDriverWindowsRelease (Display='$localWindowsReleaseDisplay', SKU='$localWindowsSku')."
+        }
     }
 
     # Get headers and user agent from Get-CoreStaticVariables
@@ -36,10 +213,10 @@ function Get-ModelsForMake {
 
     switch ($SelectedMake) {
         'Microsoft' {
-            $rawModels = Get-MicrosoftDriversModelList -Headers $Headers -UserAgent $UserAgent
+            $rawModels = Get-MicrosoftDriversModelList -Headers $Headers -UserAgent $UserAgent -DriversFolder $localDriversFolder
         }
         'Dell' {
-            $rawModels = Get-DellDriversModelList -WindowsRelease $localWindowsRelease -DriversFolder $localDriversFolder -Make $SelectedMake
+            $rawModels = Get-DellDriversModelList -WindowsRelease $localDriverWindowsRelease -DriversFolder $localDriversFolder -Make $SelectedMake
         }
         'HP' {
             $rawModels = Get-HPDriversModelList -DriversFolder $localDriversFolder -Make $SelectedMake
@@ -84,11 +261,12 @@ function ConvertTo-StandardizedDriverModel {
         [psobject]$State
     )
 
-    $modelDisplay = $RawDriverObject.Model # Default
-    $id = $RawDriverObject.Model           # Default
+    $modelDisplay = $RawDriverObject.Model
+    $id = $RawDriverObject.Model
     $link = $null
     $productName = $null
     $machineType = $null
+    $systemId = $null
 
     if ($RawDriverObject.PSObject.Properties['Link']) {
         $link = $RawDriverObject.Link
@@ -102,7 +280,30 @@ function ConvertTo-StandardizedDriverModel {
         $id = $RawDriverObject.MachineType
     }
 
-    return [PSCustomObject]@{
+    # HP specific handling
+    if ($Make -eq 'HP') {
+        $productName = if ($RawDriverObject.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($RawDriverObject.ProductName)) { $RawDriverObject.ProductName } else { ConvertTo-DriverBaseName -ModelString $RawDriverObject.Model }
+        if ([string]::IsNullOrWhiteSpace($productName)) { $productName = $RawDriverObject.Model }
+        if ($RawDriverObject.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($RawDriverObject.SystemId)) {
+            $systemId = $RawDriverObject.SystemId
+        }
+        $modelDisplay = if ([string]::IsNullOrWhiteSpace($systemId)) { $productName } else { Get-DriverDisplayName -BaseName $productName -Identifier $systemId }
+        $id = if ([string]::IsNullOrWhiteSpace($systemId)) { $productName } else { $systemId }
+    }
+
+    # Dell-specific passthrough (needed for per-model cab workflow)
+    $dellBrand = $null
+    $dellModelNumber = $null
+    $dellSystemId = $null
+    $dellCabUrl = $null
+    if ($Make -eq 'Dell') {
+        if ($RawDriverObject.PSObject.Properties['Brand']) { $dellBrand = $RawDriverObject.Brand }
+        if ($RawDriverObject.PSObject.Properties['ModelNumber']) { $dellModelNumber = $RawDriverObject.ModelNumber }
+        if ($RawDriverObject.PSObject.Properties['SystemId']) { $dellSystemId = $RawDriverObject.SystemId }
+        if ($RawDriverObject.PSObject.Properties['CabUrl']) { $dellCabUrl = $RawDriverObject.CabUrl }
+    }
+
+    $output = [PSCustomObject]@{
         IsSelected     = $false
         Make           = $Make
         Model          = $modelDisplay
@@ -110,12 +311,25 @@ function ConvertTo-StandardizedDriverModel {
         Id             = $id
         ProductName    = $productName
         MachineType    = $machineType
-        Version        = "" # Placeholder
-        Type           = "" # Placeholder
-        Size           = "" # Placeholder
-        Arch           = "" # Placeholder
-        DownloadStatus = "" # Initial download status
+        Version        = ""
+        Type           = ""
+        Size           = ""
+        Arch           = ""
+        DownloadStatus = ""
     }
+
+    if ($Make -eq 'Dell') {
+        # Add Dell-only fields so Save-DellDriversTask can use CabUrl
+        $output | Add-Member -NotePropertyName Brand           -NotePropertyValue $dellBrand
+        $output | Add-Member -NotePropertyName ModelNumber     -NotePropertyValue $dellModelNumber
+        $output | Add-Member -NotePropertyName SystemId        -NotePropertyValue $dellSystemId
+        $output | Add-Member -NotePropertyName CabUrl          -NotePropertyValue $dellCabUrl
+    }
+    elseif ($Make -eq 'HP' -and -not [string]::IsNullOrWhiteSpace($systemId)) {
+        $output | Add-Member -NotePropertyName SystemId -NotePropertyValue $systemId
+    }
+
+    return $output
 }
 
 # Function to filter the driver model list based on text input
@@ -173,7 +387,10 @@ function Save-DriversJson {
         [psobject]$State
     )
     WriteLog "Save-DriversJson function called."
-    $selectedDrivers = @($State.Controls.lstDriverModels.Items | Where-Object { $_.IsSelected })
+
+    # Save from the master model list so filtered-out selected rows are preserved.
+    $driverSelectionSource = if ($null -ne $State.Data.allDriverModels) { $State.Data.allDriverModels } else { $State.Controls.lstDriverModels.Items }
+    $selectedDrivers = @($driverSelectionSource | Where-Object { $_.IsSelected })
 
     if (-not $selectedDrivers) {
         [System.Windows.MessageBox]::Show("No drivers selected to save.", "Save Drivers", [System.Windows.MessageBoxButton]::OK, [System.Windows.MessageBoxImage]::Information)
@@ -188,35 +405,7 @@ function Save-DriversJson {
         $modelsForThisMake = @() # Initialize an array to hold model objects
 
         foreach ($driverItem in $_.Group) {
-            $modelObject = $null
-            switch ($makeName) {
-                'Microsoft' {
-                    $modelObject = @{
-                        Name = $driverItem.Model # Model is the display name
-                        Link = $driverItem.Link
-                    }
-                }
-                'Dell' {
-                    $modelObject = @{
-                        Name = $driverItem.Model
-                    }
-                }
-                'HP' {
-                    $modelObject = @{
-                        Name = $driverItem.Model
-                    }
-                }
-                'Lenovo' {
-                    $modelObject = @{
-                        Name        = $driverItem.Model       # This is "ProductName (MachineType)"
-                        ProductName = $driverItem.ProductName # This is "ProductName"
-                        MachineType = $driverItem.MachineType # This is "MachineType"
-                    }
-                }
-                default {
-                    WriteLog "Save-DriversJson: Unknown Make '$makeName' encountered for model '$($driverItem.Model)'. Skipping."
-                }
-            }
+            $modelObject = Convert-DriverItemToJsonModel -DriverItem $driverItem
             if ($null -ne $modelObject) {
                 $modelsForThisMake += $modelObject
             }
@@ -307,11 +496,97 @@ function Import-DriversJson {
                         continue
                     }
         
+                    $normalizedName = $importedModelNameFromObject
+                    $skipModel = $false
+                    switch ($makeName) {
+                        'Lenovo' {
+                            $productName = if ($importedModelObject.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.ProductName)) { $importedModelObject.ProductName } else { ConvertTo-DriverBaseName -ModelString $normalizedName }
+                            $machineType = if ($importedModelObject.PSObject.Properties['MachineType'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.MachineType)) { $importedModelObject.MachineType } else { $null }
+                            if ([string]::IsNullOrWhiteSpace($machineType) -and $normalizedName -match '(.+?)\s*\((.+?)\)$') {
+                                if ([string]::IsNullOrWhiteSpace($productName)) { $productName = $matches[1].Trim() }
+                                $machineType = $matches[2].Trim()
+                            }
+                            if ([string]::IsNullOrWhiteSpace($productName) -or [string]::IsNullOrWhiteSpace($machineType)) {
+                                WriteLog "Import-DriversJson: Skipping Lenovo model '$normalizedName' due to missing ProductName or MachineType."
+                                $skipModel = $true
+                            }
+                            else {
+                                $normalizedName = Get-DriverDisplayName -BaseName $productName -Identifier $machineType
+                                if ($importedModelObject.PSObject.Properties['ProductName']) {
+                                    $importedModelObject.ProductName = $productName
+                                }
+                                else {
+                                    $importedModelObject | Add-Member -NotePropertyName ProductName -NotePropertyValue $productName
+                                }
+                                if ($importedModelObject.PSObject.Properties['MachineType']) {
+                                    $importedModelObject.MachineType = $machineType
+                                }
+                                else {
+                                    $importedModelObject | Add-Member -NotePropertyName MachineType -NotePropertyValue $machineType
+                                }
+                            }
+                        }
+                        'Dell' {
+                            $baseName = ConvertTo-DriverBaseName -ModelString $normalizedName
+                            if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $normalizedName }
+                            $systemId = if ($importedModelObject.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.SystemId)) { $importedModelObject.SystemId } else { $null }
+                            if ([string]::IsNullOrWhiteSpace($systemId) -and $normalizedName -match '(.+?)\s*\((.+?)\)$') {
+                                if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $matches[1].Trim() }
+                                $systemId = $matches[2].Trim()
+                            }
+                            $normalizedName = if ([string]::IsNullOrWhiteSpace($systemId)) { $baseName.Trim() } else { Get-DriverDisplayName -BaseName $baseName -Identifier $systemId }
+                            if ($importedModelObject.PSObject.Properties['SystemId']) {
+                                $importedModelObject.SystemId = $systemId
+                            }
+                            else {
+                                $importedModelObject | Add-Member -NotePropertyName SystemId -NotePropertyValue $systemId
+                            }
+                        }
+                        'HP' {
+                            $baseName = ConvertTo-DriverBaseName -ModelString $normalizedName
+                            if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $normalizedName }
+                            $systemId = if ($importedModelObject.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.SystemId)) { $importedModelObject.SystemId } else { $null }
+                            if ([string]::IsNullOrWhiteSpace($systemId) -and $normalizedName -match '(.+?)\s*\((.+?)\)$') {
+                                if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $matches[1].Trim() }
+                                $systemId = $matches[2].Trim()
+                            }
+                            $normalizedName = if ([string]::IsNullOrWhiteSpace($systemId)) { $baseName.Trim() } else { Get-DriverDisplayName -BaseName $baseName -Identifier $systemId }
+                            if ($importedModelObject.PSObject.Properties['ProductName']) {
+                                $importedModelObject.ProductName = $baseName
+                            }
+                            else {
+                                $importedModelObject | Add-Member -NotePropertyName ProductName -NotePropertyValue $baseName
+                            }
+                            if ($importedModelObject.PSObject.Properties['SystemId']) {
+                                $importedModelObject.SystemId = $systemId
+                            }
+                            else {
+                                $importedModelObject | Add-Member -NotePropertyName SystemId -NotePropertyValue $systemId
+                            }
+                        }
+                        default {
+                            $normalizedName = $normalizedName.Trim()
+                        }
+                    }
+        
+                    if ($skipModel) {
+                        continue
+                    }
+        
+                    if ([string]::IsNullOrWhiteSpace($normalizedName)) {
+                        WriteLog "Import-DriversJson: Skipping normalized model name for Make '$makeName'."
+                        continue
+                    }
+        
+                    $importedModelObject.Name = $normalizedName
+                    $importedModelNameFromObject = $normalizedName
+        
                     $existingModel = $State.Data.allDriverModels | Where-Object { $_.Make -eq $makeName -and $_.Model -eq $importedModelNameFromObject } | Select-Object -First 1
 
                     if ($null -ne $existingModel) {
                         $existingModel.IsSelected = $true
                         $existingModel.DownloadStatus = "Imported"
+                        $existingModel.Model = $importedModelNameFromObject
                     
                         if ($makeName -eq 'Microsoft' -and $importedModelObject.PSObject.Properties['Link']) {
                             if ($existingModel.Link -ne $importedModelObject.Link) {
@@ -327,13 +602,36 @@ function Import-DriversJson {
                             }
                             if ($importedModelObject.PSObject.Properties['MachineType'] -and $existingModel.PSObject.Properties['MachineType'] -and $existingModel.MachineType -ne $importedModelObject.MachineType) {
                                 $existingModel.MachineType = $importedModelObject.MachineType
-                                $existingModel.Id = $importedModelObject.MachineType # Update Id as well
+                                $existingModel.Id = $importedModelObject.MachineType
                                 $updateExistingLenovo = $true
                             }
                             if ($updateExistingLenovo) {
                                 WriteLog "Import-DriversJson: Updated ProductName/MachineType/Id for existing Lenovo model '$($existingModel.Model)'."
                             }
                         }
+                        elseif ($makeName -eq 'Dell') {
+                            # Update Dell extended fields if provided
+                            if ($importedModelObject.PSObject.Properties['SystemId'] -and $existingModel.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.SystemId)) {
+                                if ($existingModel.SystemId -ne $importedModelObject.SystemId) {
+                                    $existingModel.SystemId = $importedModelObject.SystemId
+                                    WriteLog "Import-DriversJson: Updated SystemId for existing Dell model '$($existingModel.Model)'."
+                                }
+                            }
+                            if ($importedModelObject.PSObject.Properties['CabUrl'] -and $existingModel.PSObject.Properties['CabUrl'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.CabUrl)) {
+                                if ($existingModel.CabUrl -ne $importedModelObject.CabUrl) {
+                                    $existingModel.CabUrl = $importedModelObject.CabUrl
+                                    WriteLog "Import-DriversJson: Updated CabUrl for existing Dell model '$($existingModel.Model)'."
+                                }
+                            }
+                        }
+                        elseif ($makeName -eq 'HP') {
+                            $importedProductName = if ($importedModelObject.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.ProductName)) { $importedModelObject.ProductName } else { ConvertTo-DriverBaseName -ModelString $importedModelNameFromObject }
+                            if ([string]::IsNullOrWhiteSpace($importedProductName)) { $importedProductName = $importedModelNameFromObject }
+                            if ($importedModelObject.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.SystemId)) {
+                                $importedId = $importedModelObject.SystemId
+                            }
+                        }
+                    
                         $existingModelsUpdated++
                         WriteLog "Import-DriversJson: Marked existing model '$($existingModel.Make) - $($existingModel.Model)' as imported."
                     }
@@ -370,7 +668,7 @@ function Import-DriversJson {
                         $newDriverModel = [PSCustomObject]@{
                             IsSelected     = $true
                             Make           = $makeName
-                            Model          = $importedModelNameFromObject # Full display name
+                            Model          = $importedModelNameFromObject
                             Link           = $importedLink
                             Id             = $importedId
                             ProductName    = $importedProductName
@@ -381,6 +679,20 @@ function Import-DriversJson {
                             Arch           = ""
                             DownloadStatus = "Imported"
                         }
+                        if ($makeName -eq 'Dell') {
+                            # Attach optional Dell extended fields if present
+                            if ($importedModelObject.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.SystemId)) {
+                                $newDriverModel | Add-Member -NotePropertyName SystemId -NotePropertyValue $importedModelObject.SystemId
+                            }
+                            if ($importedModelObject.PSObject.Properties['CabUrl'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.CabUrl)) {
+                                $newDriverModel | Add-Member -NotePropertyName CabUrl -NotePropertyValue $importedModelObject.CabUrl
+                            }
+                        }
+                        elseif ($makeName -eq 'HP') {
+                            if ($importedModelObject.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.SystemId)) {
+                                $newDriverModel | Add-Member -NotePropertyName SystemId -NotePropertyValue $importedModelObject.SystemId
+                            }
+                        }
                         $State.Data.allDriverModels.Add($newDriverModel)
                         $newModelsAdded++
                         WriteLog "Import-DriversJson: Added new model '$($newDriverModel.Make) - $($newDriverModel.Model)' from import. ID: $($newDriverModel.Id), Link: $($newDriverModel.Link)"
@@ -565,12 +877,20 @@ function Invoke-DownloadSelectedDrivers {
 
     $localDriversFolder = $State.Controls.txtDriversFolder.Text
     $localWindowsRelease = $State.Controls.cmbWindowsRelease.SelectedItem.Value
+    $localWindowsReleaseDisplay = $State.Controls.cmbWindowsRelease.SelectedItem.Display
+    $localWindowsSku = if ($null -ne $State.Controls.cmbWindowsSKU.SelectedItem) { [string]$State.Controls.cmbWindowsSKU.SelectedItem } else { $null }
+    $localDriverWindowsRelease = Get-EffectiveDriverWindowsRelease -WindowsRelease $localWindowsRelease -WindowsReleaseDisplay $localWindowsReleaseDisplay -WindowsSku $localWindowsSku
+    if ($localDriverWindowsRelease -ne $localWindowsRelease) {
+        WriteLog "Normalized WindowsRelease for driver download from $localWindowsRelease to $localDriverWindowsRelease (Display='$localWindowsReleaseDisplay', SKU='$localWindowsSku')."
+    }
     $localWindowsArch = $State.Controls.cmbWindowsArch.SelectedItem
     $localWindowsVersion = if ($null -ne $State.Controls.cmbWindowsVersion -and $null -ne $State.Controls.cmbWindowsVersion.SelectedItem) { $State.Controls.cmbWindowsVersion.SelectedItem } else { $null }
     $coreStaticVars = Get-CoreStaticVariables
     $localHeaders = $coreStaticVars.Headers
     $localUserAgent = $coreStaticVars.UserAgent
     $compressDrivers = $State.Controls.chkCompressDriversToWIM.IsChecked
+    # Determine if we must preserve source folders (used later for PE driver harvesting)
+    $preserveSource = ($State.Controls.chkUseDriversAsPEDrivers.IsChecked -and $State.Controls.chkCompressDriversToWIM.IsChecked)
 
     $State.Controls.txtStatus.Text = "Processing all selected drivers..."
     WriteLog "Processing all selected drivers: $($selectedDrivers.Model -join ', ')"
@@ -580,10 +900,10 @@ function Invoke-DownloadSelectedDrivers {
         WriteLog "Dell drivers selected. Ensuring Dell Catalog is up-to-date..."
         try {
             $dellDriversFolder = Join-Path -Path $localDriversFolder -ChildPath "Dell"
-            $catalogBaseName = if ($localWindowsRelease -le 11) { "CatalogPC" } else { "Catalog" }
+            $catalogBaseName = if ($localDriverWindowsRelease -le 11) { "CatalogIndexPC" } else { "Catalog" }
             $dellCabFile = Join-Path -Path $dellDriversFolder -ChildPath "$($catalogBaseName).cab"
             $dellCatalogXML = Join-Path -Path $dellDriversFolder -ChildPath "$($catalogBaseName).xml"
-            $catalogUrl = if ($localWindowsRelease -le 11) { "http://downloads.dell.com/catalog/CatalogPC.cab" } else { "https://downloads.dell.com/catalog/Catalog.cab" }
+            $catalogUrl = if ($localDriverWindowsRelease -le 11) { "https://downloads.dell.com/catalog/CatalogIndexPC.cab" } else { "https://downloads.dell.com/catalog/Catalog.cab" }
 
             $downloadCatalog = $true
             if (Test-Path -Path $dellCatalogXML -PathType Leaf) {
@@ -620,15 +940,16 @@ function Invoke-DownloadSelectedDrivers {
             return
         }
     }
-
+    $preserveSource = ($State.Controls.chkUseDriversAsPEDrivers.IsChecked -and $State.Controls.chkCompressDriversToWIM.IsChecked)
     $taskArguments = @{
-        DriversFolder  = $localDriversFolder
-        WindowsRelease = $localWindowsRelease
-        WindowsArch    = $localWindowsArch
-        WindowsVersion = $localWindowsVersion
-        Headers        = $localHeaders
-        UserAgent      = $localUserAgent
-        CompressToWim  = $compressDrivers
+        DriversFolder            = $localDriversFolder
+        WindowsRelease           = $localDriverWindowsRelease
+        WindowsArch              = $localWindowsArch
+        WindowsVersion           = $localWindowsVersion
+        Headers                  = $localHeaders
+        UserAgent                = $localUserAgent
+        CompressToWim            = $compressDrivers
+        PreserveSourceOnCompress = $preserveSource
     }
 
     $parallelResults = Invoke-ParallelProcessing -ItemsToProcess $selectedDrivers `
@@ -645,13 +966,17 @@ function Invoke-DownloadSelectedDrivers {
 
     $overallSuccess = $true
     $successfullyDownloaded = [System.Collections.Generic.List[PSCustomObject]]::new()
+    $failedDownloads = [System.Collections.Generic.List[PSCustomObject]]::new()
 
     # Check the results from the parallel processing tasks
     if ($null -ne $parallelResults) {
-        # Create a lookup from the original selected drivers to get the 'Make' property,
-        # as the result object might only have 'Identifier' or 'Model'.
-        $makeLookup = @{}
-        $selectedDrivers | ForEach-Object { $makeLookup[$_.Model] = $_.Make }
+        # Create a lookup from the original selected drivers to retain full metadata for mapping.
+        $driverLookup = @{}
+        foreach ($driver in $selectedDrivers) {
+            if (-not [string]::IsNullOrWhiteSpace($driver.Model)) {
+                $driverLookup[$driver.Model] = $driver
+            }
+        }
     
         # Filter for objects that could be results, avoiding stray log strings
         foreach ($result in ($parallelResults | Where-Object { $_ -is [hashtable] })) {
@@ -666,27 +991,66 @@ function Invoke-DownloadSelectedDrivers {
             if ([string]::IsNullOrWhiteSpace($modelName)) {
                 WriteLog "Could not determine model name from result object: $($result | ConvertTo-Json -Compress -Depth 3)"
                 $overallSuccess = $false
+                $failedDownloads.Add([PSCustomObject]@{
+                        Model  = 'Unknown model'
+                        Status = 'Driver task returned without a model identifier.'
+                    })
                 continue
             }
 
             if ($resultCode -ne 0) {
                 $overallSuccess = $false
+                $failureStatus = $result['Status']
+                if ([string]::IsNullOrWhiteSpace($failureStatus)) { $failureStatus = 'Driver download failed. Check the log for details.' }
+                $failedDownloads.Add([PSCustomObject]@{
+                        Model  = $modelName
+                        Status = $failureStatus
+                    })
                 WriteLog "Error detected for model $modelName."
             }
             elseif (-not [string]::IsNullOrWhiteSpace($driverPath)) {
                 # The task was successful and returned a driver path.
-                $make = $makeLookup[$modelName]
-                if ($make) {
-                    $successfullyDownloaded.Add([PSCustomObject]@{
-                            Make       = $make
-                            Model      = $modelName
-                            DriverPath = $driverPath
-                        })
+                $driverMetadata = $null
+                if (-not [string]::IsNullOrWhiteSpace($modelName) -and $driverLookup.ContainsKey($modelName)) {
+                    $driverMetadata = $driverLookup[$modelName]
+                }
+
+                if ($driverMetadata) {
+                    $driverRecord = [PSCustomObject]@{
+                        Make       = $driverMetadata.Make
+                        Model      = $modelName
+                        DriverPath = $driverPath
+                    }
+
+                    if ($driverMetadata.PSObject.Properties['Link'] -and -not [string]::IsNullOrWhiteSpace($driverMetadata.Link)) {
+                        $driverRecord | Add-Member -NotePropertyName Link -NotePropertyValue $driverMetadata.Link
+                    }
+
+                    if ($driverMetadata.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($driverMetadata.SystemId)) {
+                        $driverRecord | Add-Member -NotePropertyName SystemId -NotePropertyValue $driverMetadata.SystemId
+                    }
+                    if ($driverMetadata.PSObject.Properties['MachineType'] -and -not [string]::IsNullOrWhiteSpace($driverMetadata.MachineType)) {
+                        $driverRecord | Add-Member -NotePropertyName MachineType -NotePropertyValue $driverMetadata.MachineType
+                    }
+                    if ($driverMetadata.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($driverMetadata.ProductName)) {
+                        $driverRecord | Add-Member -NotePropertyName ProductName -NotePropertyValue $driverMetadata.ProductName
+                    }
+                    $successfullyDownloaded.Add($driverRecord)
                 }
                 else {
-                    WriteLog "Warning: Could not find 'Make' for successful download of model '$modelName'. Skipping from DriverMapping.json."
+                    WriteLog "Warning: Could not find driver metadata for successful download of model '$modelName'. Skipping from DriverMapping.json."
                 }
             }
+            else {
+                $overallSuccess = $false
+                $fallbackStatus = $result['Status']
+                if ([string]::IsNullOrWhiteSpace($fallbackStatus)) { $fallbackStatus = 'Driver download did not return a driver path.' }
+                $failedDownloads.Add([PSCustomObject]@{
+                        Model  = $modelName
+                        Status = $fallbackStatus
+                    })
+                WriteLog "Driver download did not provide a path for model $modelName."
+            }
         }
     }
 
@@ -714,43 +1078,17 @@ function Invoke-DownloadSelectedDrivers {
                 $makeName = $_.Name
                 $modelsForThisMake = @() # Initialize an array to hold model objects
 
-                foreach ($driverItem in $_.Group) {
-                    $modelObject = $null
-                    switch ($makeName) {
-                        'Microsoft' {
-                            $modelObject = @{
-                                Name = $driverItem.Model # Model is the display name
-                                Link = $driverItem.Link
-                            }
-                        }
-                        'Dell' {
-                            $modelObject = @{
-                                Name = $driverItem.Model # Model is the display name
-                            }
-                        }
-                        'HP' {
-                            $modelObject = @{
-                                Name = $driverItem.Model
-                            }
-                        }
-                        'Lenovo' {
-                            $modelObject = @{
-                                Name        = $driverItem.Model
-                                ProductName = $driverItem.ProductName
-                                MachineType = $driverItem.MachineType
-                            }
-                        }
-                        default {
-                            WriteLog "Auto-Save Drivers.json: Unrecognized Make '$makeName' for driver '$($driverItem.Model)'. Skipping."
+                            foreach ($driverItem in $_.Group) {
+                        $modelObject = Convert-DriverItemToJsonModel -DriverItem $driverItem
+                        if ($null -ne $modelObject) {
+                            $modelsForThisMake += $modelObject
                         }
                     }
-                    if ($null -ne $modelObject) {
-                        $modelsForThisMake += $modelObject
+            
+                    if ($modelsForThisMake.Count -gt 0) {
+                        $outputJson[$makeName] = @{ Models = $modelsForThisMake }
                     }
                 }
-                # Add the models array to the make-specific object
-                $outputJson[$makeName] = @{ Models = $modelsForThisMake }
-            }
 
             # Ensure directory exists
             $parentDir = Split-Path -Path $driversJsonPath -Parent
@@ -775,8 +1113,21 @@ function Invoke-DownloadSelectedDrivers {
         [System.Windows.MessageBox]::Show("All selected driver downloads processed. Check status column for details.", "Download Process Finished", "OK", "Information")
     }
     else {
-        $State.Controls.txtStatus.Text = "Driver downloads processed with some errors. Check status column and log."
-        [System.Windows.MessageBox]::Show("Driver downloads processed, but some errors occurred. Please check the status column for each driver and the log file for details.", "Download Process Finished with Errors", "OK", "Warning")
+        $State.Controls.txtStatus.Text = "Driver download failed. Resolve the errors and try again."
+        $messageLines = [System.Collections.Generic.List[string]]::new()
+        if ($failedDownloads.Count -gt 0) {
+            $messageLines.Add("Driver download failed for:")
+            foreach ($item in ($failedDownloads | Select-Object -First 5)) {
+                $messageLines.Add("- $($item.Model): $($item.Status)")
+            }
+            if ($failedDownloads.Count -gt 5) {
+                $messageLines.Add("...see the log for additional failures.")
+            }
+        }
+        else {
+            $messageLines.Add("One or more driver downloads failed. Check the log for details.")
+        }
+        [System.Windows.MessageBox]::Show(($messageLines -join [System.Environment]::NewLine), "Driver Download Failed", "OK", "Error")
     }
 }
 

FFUDevelopment/FFUUI.Core/FFUUI.Core.Handlers.psm1

@@ -152,6 +152,61 @@ function Register-EventHandlers {
             $localState.Controls.chkPromptExternalHardDiskMedia.IsChecked = $false
         })
 
+    if ($null -ne $State.Controls.cmbBitsPriority) {
+        $State.Controls.cmbBitsPriority.Add_SelectionChanged({
+                param($eventSource, $selectionChangedEventArgs)
+                $window = [System.Windows.Window]::GetWindow($eventSource)
+                if ($null -eq $window -or $null -eq $window.Tag) {
+                    return
+                }
+                Update-BitsPrioritySetting -State $window.Tag
+            })
+    }
+
+    # Additional FFU Files events
+    $State.Controls.chkCopyAdditionalFFUFiles.Add_Checked({
+            param($eventSource, $routedEventArgs)
+            $window = [System.Windows.Window]::GetWindow($eventSource)
+            $localState = $window.Tag
+            $localState.Controls.additionalFFUPanel.Visibility = 'Visible'
+            Update-AdditionalFFUList -State $localState
+        })
+    $State.Controls.chkCopyAdditionalFFUFiles.Add_Unchecked({
+            param($eventSource, $routedEventArgs)
+            $window = [System.Windows.Window]::GetWindow($eventSource)
+            $localState = $window.Tag
+            $localState.Controls.additionalFFUPanel.Visibility = 'Collapsed'
+            $localState.Controls.lstAdditionalFFUs.Items.Clear()
+            $headerChk = $localState.Controls.chkSelectAllAdditionalFFUs
+            if ($null -ne $headerChk) {
+                Update-SelectAllHeaderCheckBoxState -ListView $localState.Controls.lstAdditionalFFUs -HeaderCheckBox $headerChk
+            }
+        })
+    $State.Controls.btnRefreshAdditionalFFUs.Add_Click({
+            param($eventSource, $routedEventArgs)
+            $window = [System.Windows.Window]::GetWindow($eventSource)
+            $localState = $window.Tag
+            Update-AdditionalFFUList -State $localState
+        })
+    $State.Controls.lstAdditionalFFUs.Add_PreviewKeyDown({
+            param($eventSource, $keyEvent)
+            if ($keyEvent.Key -eq 'Space') {
+                $window = [System.Windows.Window]::GetWindow($eventSource)
+                $localState = $window.Tag
+                Invoke-ListViewItemToggle -ListView $eventSource -State $localState -HeaderCheckBoxKeyName 'chkSelectAllAdditionalFFUs'
+                $keyEvent.Handled = $true
+            }
+        })
+    $State.Controls.lstAdditionalFFUs.Add_SelectionChanged({
+            param($eventSource, $selChangeEvent)
+            $window = [System.Windows.Window]::GetWindow($eventSource)
+            $localState = $window.Tag
+            $headerChk = $localState.Controls.chkSelectAllAdditionalFFUs
+            if ($null -ne $headerChk) {
+                Update-SelectAllHeaderCheckBoxState -ListView $localState.Controls.lstAdditionalFFUs -HeaderCheckBox $headerChk
+            }
+        })
+
     $State.Controls.btnCheckUSBDrives.Add_Click({
             param($eventSource, $routedEventArgs)
             $window = [System.Windows.Window]::GetWindow($eventSource)
@@ -216,11 +271,11 @@ function Register-EventHandlers {
             }
             else {
                 $localState.Controls.txtCustomVMSwitchName.Visibility = 'Collapsed'
-                if ($localState.Data.vmSwitchMap.ContainsKey($selectedItem)) {
+                if ($null -ne $selectedItem -and $localState.Data.vmSwitchMap.ContainsKey($selectedItem)) {
                     $localState.Controls.txtVMHostIPAddress.Text = $localState.Data.vmSwitchMap[$selectedItem]
                 }
                 else {
-                    $localState.Controls.txtVMHostIPAddress.Text = '' # Clear IP if not found in map
+                    $localState.Controls.txtVMHostIPAddress.Text = '' # Clear IP if not found or key null
                 }
             }
         })
@@ -262,6 +317,9 @@ function Register-EventHandlers {
             Update-WindowsVersionCombo -selectedRelease $selectedReleaseValue -isoPath $localState.Controls.txtISOPath.Text -State $localState
             Update-WindowsSkuCombo -State $localState
             Update-WindowsArchCombo -State $localState
+
+            # Re-evaluate Install Apps dependency when Windows release changes
+            Update-InstallAppsState -State $localState
         })
 
     $State.Controls.cmbWindowsVersion.Add_SelectionChanged({
@@ -314,6 +372,8 @@ function Register-EventHandlers {
     $State.Controls.chkUpdateOneDrive.Add_Unchecked($updateCheckboxHandler)
     $State.Controls.chkUpdateLatestMSRT.Add_Checked($updateCheckboxHandler)
     $State.Controls.chkUpdateLatestMSRT.Add_Unchecked($updateCheckboxHandler)
+    $State.Controls.chkUpdateLatestCU.Add_Checked($updateCheckboxHandler)
+    $State.Controls.chkUpdateLatestCU.Add_Unchecked($updateCheckboxHandler)
     
     # Also attach the handler to the Office checkbox
     $State.Controls.chkInstallOffice.Add_Checked($updateCheckboxHandler)
@@ -808,6 +868,10 @@ function Register-EventHandlers {
     $State.Controls.chkCopyDrivers.Add_Unchecked($driverCheckboxHandler)
     $State.Controls.chkCompressDriversToWIM.Add_Checked($driverCheckboxHandler)
     $State.Controls.chkCompressDriversToWIM.Add_Unchecked($driverCheckboxHandler)
+    $State.Controls.chkCopyPEDrivers.Add_Checked($driverCheckboxHandler)
+    $State.Controls.chkCopyPEDrivers.Add_Unchecked($driverCheckboxHandler)
+    $State.Controls.chkUseDriversAsPEDrivers.Add_Checked($driverCheckboxHandler)
+    $State.Controls.chkUseDriversAsPEDrivers.Add_Unchecked($driverCheckboxHandler)
 
     $State.Controls.btnBrowseDriversFolder.Add_Click({
             param($eventSource, $routedEventArgs)
@@ -950,6 +1014,12 @@ function Register-EventHandlers {
             $localState = $window.Tag
             Invoke-LoadConfiguration -State $localState
         })
+    $State.Controls.btnRestoreDefaults.Add_Click({
+            param($eventSource, $routedEventArgs)
+            $window = [System.Windows.Window]::GetWindow($eventSource)
+            $localState = $window.Tag
+            Invoke-RestoreDefaults -State $localState
+        })
     $State.Controls.btnBuildConfig.Add_Click({
             param($eventSource, $routedEventArgs)
             $window = [System.Windows.Window]::GetWindow($eventSource)

FFUDevelopment/FFUUI.Core/FFUUI.Core.Initialize.psm1

@@ -59,6 +59,10 @@ function Initialize-UIControls {
     $State.Controls.usbSelectionPanel = $window.FindName('usbDriveSelectionPanel')
     $State.Controls.chkAllowExternalHardDiskMedia = $window.FindName('chkAllowExternalHardDiskMedia')
     $State.Controls.chkPromptExternalHardDiskMedia = $window.FindName('chkPromptExternalHardDiskMedia')
+    $State.Controls.chkCopyAdditionalFFUFiles = $window.FindName('chkCopyAdditionalFFUFiles')
+    $State.Controls.additionalFFUPanel = $window.FindName('additionalFFUPanel')
+    $State.Controls.lstAdditionalFFUs = $window.FindName('lstAdditionalFFUs')
+    $State.Controls.btnRefreshAdditionalFFUs = $window.FindName('btnRefreshAdditionalFFUs')
     $State.Controls.chkInstallWingetApps = $window.FindName('chkInstallWingetApps')
     $State.Controls.wingetPanel = $window.FindName('wingetPanel')
     $State.Controls.btnCheckWingetModule = $window.FindName('btnCheckWingetModule')
@@ -114,6 +118,7 @@ function Initialize-UIControls {
     $State.Controls.txtShareName = $window.FindName('txtShareName')
     $State.Controls.txtUsername = $window.FindName('txtUsername')
     $State.Controls.txtThreads = $window.FindName('txtThreads')
+    $State.Controls.cmbBitsPriority = $window.FindName('cmbBitsPriority')
     $State.Controls.txtMaxUSBDrives = $window.FindName('txtMaxUSBDrives')
     $State.Controls.chkCompactOS = $window.FindName('chkCompactOS')
     $State.Controls.chkOptimize = $window.FindName('chkOptimize')
@@ -130,6 +135,7 @@ function Initialize-UIControls {
     $State.Controls.chkCleanupDeployISO = $window.FindName('chkCleanupDeployISO')
     $State.Controls.chkCleanupDrivers = $window.FindName('chkCleanupDrivers')
     $State.Controls.chkRemoveFFU = $window.FindName('chkRemoveFFU')
+    $State.Controls.chkRemoveDownloadedESD = $window.FindName('chkRemoveDownloadedESD')
     $State.Controls.txtDiskSize = $window.FindName('txtDiskSize')
     $State.Controls.txtMemory = $window.FindName('txtMemory')
     $State.Controls.txtProcessors = $window.FindName('txtProcessors')
@@ -143,6 +149,7 @@ function Initialize-UIControls {
     $State.Controls.txtDriversFolder = $window.FindName('txtDriversFolder')
     $State.Controls.txtPEDriversFolder = $window.FindName('txtPEDriversFolder')
     $State.Controls.chkCopyPEDrivers = $window.FindName('chkCopyPEDrivers')
+    $State.Controls.chkUseDriversAsPEDrivers = $window.FindName('chkUseDriversAsPEDrivers')
     $State.Controls.chkUpdateLatestCU = $window.FindName('chkUpdateLatestCU')
     $State.Controls.chkUpdateLatestNet = $window.FindName('chkUpdateLatestNet')
     $State.Controls.chkUpdateLatestDefender = $window.FindName('chkUpdateLatestDefender')
@@ -170,6 +177,7 @@ function Initialize-UIControls {
     $State.Controls.btnBrowseDriversJsonPath = $window.FindName('btnBrowseDriversJsonPath')
     $State.Controls.chkUpdateADK = $window.FindName('chkUpdateADK')
     $State.Controls.btnLoadConfig = $window.FindName('btnLoadConfig')
+    $State.Controls.btnRestoreDefaults = $window.FindName('btnRestoreDefaults')
     $State.Controls.btnBuildConfig = $window.FindName('btnBuildConfig')
 
     # Monitor Tab
@@ -198,11 +206,11 @@ function Initialize-VMSwitchData {
     if ($State.Controls.cmbVMSwitchName.Items.Count -gt 1) {
         $State.Controls.cmbVMSwitchName.SelectedIndex = 0
         $firstSwitch = $State.Controls.cmbVMSwitchName.SelectedItem
-        if ($State.Data.vmSwitchMap.ContainsKey($firstSwitch)) {
+        if ($null -ne $firstSwitch -and $State.Data.vmSwitchMap.ContainsKey($firstSwitch)) {
             $State.Controls.txtVMHostIPAddress.Text = $State.Data.vmSwitchMap[$firstSwitch]
         }
         else {
-            $State.Controls.txtVMHostIPAddress.Text = $State.Defaults.generalDefaults.VMHostIPAddress # Use default if IP not found
+            $State.Controls.txtVMHostIPAddress.Text = $State.Defaults.generalDefaults.VMHostIPAddress # Use default if IP not found or key null
         }
         $State.Controls.txtCustomVMSwitchName.Visibility = 'Collapsed'
     }
@@ -228,6 +236,7 @@ function Initialize-UIDefaults {
     $State.Controls.txtShareName.Text = $State.Defaults.generalDefaults.ShareName
     $State.Controls.txtUsername.Text = $State.Defaults.generalDefaults.Username
     $State.Controls.txtThreads.Text = $State.Defaults.generalDefaults.Threads
+    $State.Controls.cmbBitsPriority.SelectedItem = $State.Defaults.generalDefaults.BitsPriority
     $State.Controls.txtMaxUSBDrives.Text = $State.Defaults.generalDefaults.MaxUSBDrives
     $State.Controls.chkBuildUSBDriveEnable.IsChecked = $State.Defaults.generalDefaults.BuildUSBDriveEnable
     $State.Controls.chkCompactOS.IsChecked = $State.Defaults.generalDefaults.CompactOS
@@ -250,11 +259,15 @@ function Initialize-UIDefaults {
     $State.Controls.chkRemoveFFU.IsChecked = $State.Defaults.generalDefaults.RemoveFFU
     $State.Controls.chkRemoveApps.IsChecked = $State.Defaults.generalDefaults.RemoveApps
     $State.Controls.chkRemoveUpdates.IsChecked = $State.Defaults.generalDefaults.RemoveUpdates
+    $State.Controls.chkRemoveDownloadedESD.IsChecked = $State.Defaults.generalDefaults.RemoveDownloadedESD
     $State.Controls.chkVerbose.IsChecked = $State.Defaults.generalDefaults.Verbose
     $State.Controls.usbSection.Visibility = if ($State.Controls.chkBuildUSBDriveEnable.IsChecked) { 'Visible' } else { 'Collapsed' }
     $State.Controls.usbSelectionPanel.Visibility = if ($State.Controls.chkSelectSpecificUSBDrives.IsChecked) { 'Visible' } else { 'Collapsed' }
     $State.Controls.chkSelectSpecificUSBDrives.IsEnabled = $State.Controls.chkBuildUSBDriveEnable.IsChecked
     $State.Controls.chkPromptExternalHardDiskMedia.IsEnabled = $State.Controls.chkAllowExternalHardDiskMedia.IsChecked
+    $State.Controls.chkCopyAdditionalFFUFiles.IsChecked = $State.Defaults.generalDefaults.CopyAdditionalFFUFiles
+    $State.Controls.additionalFFUPanel.Visibility = if ($State.Controls.chkCopyAdditionalFFUFiles.IsChecked) { 'Visible' } else { 'Collapsed' }
+    Update-BitsPrioritySetting -State $State
 
     # Hyper-V Settings defaults from General Defaults
     Initialize-VMSwitchData -State $State
@@ -309,15 +322,20 @@ function Initialize-UIDefaults {
     $State.Controls.chkInstallDrivers.IsChecked = $State.Defaults.generalDefaults.InstallDrivers
     $State.Controls.chkCopyDrivers.IsChecked = $State.Defaults.generalDefaults.CopyDrivers
     $State.Controls.chkCopyPEDrivers.IsChecked = $State.Defaults.generalDefaults.CopyPEDrivers
+    $State.Controls.chkUseDriversAsPEDrivers.IsChecked = $State.Defaults.generalDefaults.UseDriversAsPEDrivers
     $State.Controls.chkCompressDriversToWIM.IsChecked = $State.Defaults.generalDefaults.CompressDownloadedDriversToWim
 
     # Drivers tab UI logic
     $makeList = @('Microsoft', 'Dell', 'HP', 'Lenovo')
-    foreach ($m in $makeList) {
-        [void]$State.Controls.cmbMake.Items.Add($m)
-    }
-    if ($State.Controls.cmbMake.Items.Count -gt 0) {
-        $State.Controls.cmbMake.SelectedIndex = 0
+    if ($null -ne $State.Controls.cmbMake) {
+        # Clear existing items to prevent duplication on re-initialization (e.g., after Restore Defaults)
+        $State.Controls.cmbMake.Items.Clear()
+        foreach ($m in $makeList) {
+            [void]$State.Controls.cmbMake.Items.Add($m)
+        }
+        if ($State.Controls.cmbMake.Items.Count -gt 0) {
+            $State.Controls.cmbMake.SelectedIndex = 0
+        }
     }
     Update-DriverDownloadPanelVisibility -State $State
 
@@ -350,8 +368,8 @@ function Initialize-DynamicUIElements {
     $driverModelsGridView = New-Object System.Windows.Controls.GridView
     $State.Controls.lstDriverModels.View = $driverModelsGridView # Assign GridView to ListView first
 
-    # Add the selectable column using the new function
-    Add-SelectableGridViewColumn -ListView $State.Controls.lstDriverModels -State $State -HeaderCheckBoxKeyName "chkSelectAllDriverModels" -ColumnWidth 70
+    # Add the selectable column and scope header select-all to visible filtered rows.
+    Add-SelectableGridViewColumn -ListView $State.Controls.lstDriverModels -State $State -HeaderCheckBoxKeyName "chkSelectAllDriverModels" -ColumnWidth 70 -HeaderSelectionAffectsVisibleItemsOnly
 
     # Add other sortable columns with left-aligned headers
     Add-SortableColumn -gridView $driverModelsGridView -header "Make" -binding "Make" -width 100 -headerHorizontalAlignment Left
@@ -443,6 +461,75 @@ function Initialize-DynamicUIElements {
     $wingetGridView.Columns.Add($archColumn)
     # --- END: Add Architecture Column ---
 
+    # --- START: Add Additional Exit Codes Column ---
+    $exitCodesColumn = New-Object System.Windows.Controls.GridViewColumn
+    $exitCodesHeader = New-Object System.Windows.Controls.GridViewColumnHeader
+    $exitCodesHeader.Tag = "AdditionalExitCodes"
+    $exitCodesHeader.HorizontalContentAlignment = [System.Windows.HorizontalAlignment]::Left
+
+    $exitHeaderTextFactory = New-Object System.Windows.FrameworkElementFactory([System.Windows.Controls.TextBlock])
+    $exitHeaderTextFactory.SetValue([System.Windows.Controls.TextBlock]::TextProperty, "Additional Exit Codes")
+    $exitHeaderTextFactory.SetValue([System.Windows.Controls.TextBlock]::PaddingProperty, (New-Object System.Windows.Thickness(5, 2, 5, 2)))
+    $exitHeaderTextFactory.SetValue([System.Windows.FrameworkElement]::VerticalAlignmentProperty, [System.Windows.VerticalAlignment]::Center)
+
+    $exitHeaderTemplate = New-Object System.Windows.DataTemplate
+    $exitHeaderTemplate.VisualTree = $exitHeaderTextFactory
+    $exitCodesHeader.ContentTemplate = $exitHeaderTemplate
+
+    $exitCodesColumn.Header = $exitCodesHeader
+    $exitCodesColumn.Width = 140
+
+    $exitCodesCellTemplate = New-Object System.Windows.DataTemplate
+    $exitCodesTextBoxFactory = New-Object System.Windows.FrameworkElementFactory([System.Windows.Controls.TextBox])
+    $exitBinding = New-Object System.Windows.Data.Binding("AdditionalExitCodes")
+    $exitBinding.Mode = [System.Windows.Data.BindingMode]::TwoWay
+    $exitCodesTextBoxFactory.SetBinding([System.Windows.Controls.TextBox]::TextProperty, $exitBinding)
+    $exitCodesCellTemplate.VisualTree = $exitCodesTextBoxFactory
+    $exitCodesColumn.CellTemplate = $exitCodesCellTemplate
+    $wingetGridView.Columns.Add($exitCodesColumn)
+    # --- END: Add Additional Exit Codes Column ---
+
+    # --- START: Add Ignore Non-Zero Exit Codes Column ---
+    $ignoreColumn = New-Object System.Windows.Controls.GridViewColumn
+    $ignoreHeader = New-Object System.Windows.Controls.GridViewColumnHeader
+    $ignoreHeader.Tag = "IgnoreNonZeroExitCodes"
+    $ignoreHeader.HorizontalContentAlignment = [System.Windows.HorizontalAlignment]::Left
+
+    $ignoreHeaderTextFactory = New-Object System.Windows.FrameworkElementFactory([System.Windows.Controls.TextBlock])
+    $ignoreHeaderTextFactory.SetValue([System.Windows.Controls.TextBlock]::TextProperty, "Ignore Exit Codes")
+    $ignoreHeaderTextFactory.SetValue([System.Windows.Controls.TextBlock]::PaddingProperty, (New-Object System.Windows.Thickness(5, 2, 5, 2)))
+    $ignoreHeaderTextFactory.SetValue([System.Windows.FrameworkElement]::VerticalAlignmentProperty, [System.Windows.VerticalAlignment]::Center)
+
+    $ignoreHeaderTemplate = New-Object System.Windows.DataTemplate
+    $ignoreHeaderTemplate.VisualTree = $ignoreHeaderTextFactory
+    $ignoreHeader.ContentTemplate = $ignoreHeaderTemplate
+
+    $ignoreColumn.Header = $ignoreHeader
+    $ignoreColumn.Width = 140
+
+    $ignoreCellTemplate = New-Object System.Windows.DataTemplate
+
+    # Center the checkbox in the cell
+    $ignoreCellGridFactory = New-Object System.Windows.FrameworkElementFactory([System.Windows.Controls.Grid])
+    $ignoreCellGridFactory.SetValue([System.Windows.FrameworkElement]::HorizontalAlignmentProperty, [System.Windows.HorizontalAlignment]::Stretch)
+    $ignoreCellGridFactory.SetValue([System.Windows.FrameworkElement]::VerticalAlignmentProperty, [System.Windows.VerticalAlignment]::Stretch)
+
+    $ignoreCheckFactory = New-Object System.Windows.FrameworkElementFactory([System.Windows.Controls.CheckBox])
+    $ignoreCheckFactory.SetValue([System.Windows.FrameworkElement]::HorizontalAlignmentProperty, [System.Windows.HorizontalAlignment]::Center)
+    $ignoreCheckFactory.SetValue([System.Windows.FrameworkElement]::VerticalAlignmentProperty, [System.Windows.VerticalAlignment]::Center)
+
+    $ignoreBinding = New-Object System.Windows.Data.Binding("IgnoreNonZeroExitCodes")
+    $ignoreBinding.Mode = [System.Windows.Data.BindingMode]::TwoWay
+    $ignoreCheckFactory.SetBinding([System.Windows.Controls.Primitives.ToggleButton]::IsCheckedProperty, $ignoreBinding)
+
+    # Build the visual tree: Grid -> CheckBox
+    $ignoreCellGridFactory.AppendChild($ignoreCheckFactory)
+    $ignoreCellTemplate.VisualTree = $ignoreCellGridFactory
+
+    $ignoreColumn.CellTemplate = $ignoreCellTemplate
+    $wingetGridView.Columns.Add($ignoreColumn)
+    # --- END: Add Ignore Non-Zero Exit Codes Column ---
+
     Add-SortableColumn -gridView $wingetGridView -header "Download Status" -binding "DownloadStatus" -width 150 -headerHorizontalAlignment Left
     $State.Controls.lstWingetResults.AddHandler(
         [System.Windows.Controls.GridViewColumnHeader]::ClickEvent,
@@ -570,14 +657,14 @@ function Initialize-DynamicUIElements {
             $modelColumn.Header = $modelHeader
         }
     
-        # Serial Number Column (index 1 in XAML, now 2)
+        # Unique ID Column (index 1 in XAML, now 2)
         if ($usbDrivesGridView.Columns.Count -gt 2) {
-            $serialColumn = $usbDrivesGridView.Columns[2]
-            $serialHeader = New-Object System.Windows.Controls.GridViewColumnHeader
-            $serialHeader.Content = "Serial Number"
-            $serialHeader.Tag = "SerialNumber" # Property to sort by
-            $serialHeader.HorizontalContentAlignment = [System.Windows.HorizontalAlignment]::Left
-            $serialColumn.Header = $serialHeader
+            $uniqueIdColumn = $usbDrivesGridView.Columns[2]
+            $uniqueIdHeader = New-Object System.Windows.Controls.GridViewColumnHeader
+            $uniqueIdHeader.Content = "Unique ID"
+            $uniqueIdHeader.Tag = "UniqueId" # Property to sort by
+            $uniqueIdHeader.HorizontalContentAlignment = [System.Windows.HorizontalAlignment]::Left
+            $uniqueIdColumn.Header = $uniqueIdHeader
         }
     
         # Size Column (index 2 in XAML, now 3)
@@ -610,6 +697,51 @@ function Initialize-DynamicUIElements {
     else {
         WriteLog "Warning: lstUSBDrives.View is not a GridView. Selectable column not added, and sorting cannot be enabled."
     }
+    
+    # Additional FFUs ListView setup
+    $itemStyleAdditionalFFUs = New-Object System.Windows.Style([System.Windows.Controls.ListViewItem])
+    $itemStyleAdditionalFFUs.Setters.Add((New-Object System.Windows.Setter([System.Windows.Controls.ListViewItem]::HorizontalContentAlignmentProperty, [System.Windows.HorizontalAlignment]::Stretch)))
+    $State.Controls.lstAdditionalFFUs.ItemContainerStyle = $itemStyleAdditionalFFUs
+    
+    if ($State.Controls.lstAdditionalFFUs.View -is [System.Windows.Controls.GridView]) {
+        Add-SelectableGridViewColumn -ListView $State.Controls.lstAdditionalFFUs -State $State -HeaderCheckBoxKeyName "chkSelectAllAdditionalFFUs" -ColumnWidth 70
+    
+        $additionalFFUsGridView = $State.Controls.lstAdditionalFFUs.View
+    
+        if ($additionalFFUsGridView.Columns.Count -gt 1) {
+            $nameColumn = $additionalFFUsGridView.Columns[1]
+            $nameHeader = New-Object System.Windows.Controls.GridViewColumnHeader
+            $nameHeader.Content = "FFU Name"
+            $nameHeader.Tag = "Name"
+            $nameHeader.HorizontalContentAlignment = [System.Windows.HorizontalAlignment]::Left
+            $nameColumn.Header = $nameHeader
+        }
+        if ($additionalFFUsGridView.Columns.Count -gt 2) {
+            $lastModColumn = $additionalFFUsGridView.Columns[2]
+            $lastModHeader = New-Object System.Windows.Controls.GridViewColumnHeader
+            $lastModHeader.Content = "Last Modified"
+            $lastModHeader.Tag = "LastModified"
+            $lastModHeader.HorizontalContentAlignment = [System.Windows.HorizontalAlignment]::Left
+            $lastModColumn.Header = $lastModHeader
+        }
+    
+        $State.Controls.lstAdditionalFFUs.AddHandler(
+            [System.Windows.Controls.GridViewColumnHeader]::ClickEvent,
+            [System.Windows.RoutedEventHandler] {
+                param($eventSource, $e)
+                $header = $e.OriginalSource
+                if ($header -is [System.Windows.Controls.GridViewColumnHeader] -and $header.Tag) {
+                    $listViewControl = $eventSource
+                    $window = [System.Windows.Window]::GetWindow($listViewControl)
+                    $uiStateFromWindowTag = $window.Tag
+                    Invoke-ListViewSort -listView $eventSource -property $header.Tag -State $uiStateFromWindowTag
+                }
+            }
+        )
+    }
+    else {
+        WriteLog "Warning: lstAdditionalFFUs.View is not a GridView. Selectable column not added, and sorting cannot be enabled."
+    }
 }
 
 

FFUDevelopment/FFUUI.Core/FFUUI.Core.Shared.psm1

@@ -220,6 +220,32 @@ function Invoke-ProgressUpdate {
     $ProgressQueue.Enqueue(@{ Identifier = $Identifier; Status = $Status })
 }
 
+function Update-BitsPrioritySetting {
+    param(
+        [Parameter(Mandatory)]
+        [pscustomobject]$State
+    )
+
+    $combo = $State.Controls.cmbBitsPriority
+    if ($null -eq $combo) {
+        WriteLog "BITS priority control not available; skipping priority update."
+        return
+    }
+
+    $selectedPriority = $combo.SelectedItem
+    if ([string]::IsNullOrWhiteSpace($selectedPriority)) {
+        $selectedPriority = 'Normal'
+    }
+
+    try {
+        Set-BitsTransferPriority -Priority $selectedPriority
+        WriteLog "BITS transfer priority set to $selectedPriority."
+    }
+    catch {
+        WriteLog "Failed to set BITS transfer priority: $($_.Exception.Message)"
+    }
+}
+
 # Add a function to create a sortable list view
 function Add-SortableColumn {
     param(
@@ -303,7 +329,8 @@ function Add-SelectableGridViewColumn {
         [string]$HeaderCheckBoxKeyName,
         [Parameter(Mandatory)]
         [double]$ColumnWidth,
-        [string]$IsSelectedPropertyName = "IsSelected"
+        [string]$IsSelectedPropertyName = "IsSelected",
+        [switch]$HeaderSelectionAffectsVisibleItemsOnly
     )
 
     # Ensure the ListView has a GridView
@@ -317,10 +344,11 @@ function Add-SelectableGridViewColumn {
     $headerCheckBox = New-Object System.Windows.Controls.CheckBox
     $headerCheckBox.HorizontalAlignment = [System.Windows.HorizontalAlignment]::Center
     
-    # MODIFICATION: Store the actual ListView object in the header's Tag
+    # Store header metadata, including whether select-all should only affect visible rows.
     $headerTagObject = [PSCustomObject]@{
-        PropertyName    = $IsSelectedPropertyName
-        ListViewControl = $ListView 
+        PropertyName                           = $IsSelectedPropertyName
+        ListViewControl                        = $ListView
+        HeaderSelectionAffectsVisibleItemsOnly = [bool]$HeaderSelectionAffectsVisibleItemsOnly
     }
     $headerCheckBox.Tag = $headerTagObject
 
@@ -330,8 +358,24 @@ function Add-SelectableGridViewColumn {
             $localPropertyName = $tagData.PropertyName
             $actualListView = $tagData.ListViewControl
 
-            $collectionToUpdate = if ($null -ne $actualListView.ItemsSource) { $actualListView.ItemsSource } else { $actualListView.Items }
-            if ($null -ne $collectionToUpdate) {
+            # Select either visible view items only (filtered scope) or the full backing list.
+            $collectionToUpdate = @()
+            if ($tagData.HeaderSelectionAffectsVisibleItemsOnly -and $null -ne $actualListView.ItemsSource) {
+                $collectionView = [System.Windows.Data.CollectionViewSource]::GetDefaultView($actualListView.ItemsSource)
+                if ($null -ne $collectionView) {
+                    foreach ($visibleItem in $collectionView) {
+                        $collectionToUpdate += $visibleItem
+                    }
+                }
+            }
+            elseif ($null -ne $actualListView.ItemsSource) {
+                $collectionToUpdate = @($actualListView.ItemsSource)
+            }
+            elseif ($actualListView.HasItems) {
+                $collectionToUpdate = @($actualListView.Items)
+            }
+
+            if ($collectionToUpdate.Count -gt 0) {
                 foreach ($item in $collectionToUpdate) { $item.$($localPropertyName) = $true }
                 $actualListView.Items.Refresh()
             }
@@ -344,8 +388,24 @@ function Add-SelectableGridViewColumn {
                 $localPropertyName = $tagData.PropertyName
                 $actualListView = $tagData.ListViewControl 
 
-                $collectionToUpdate = if ($null -ne $actualListView.ItemsSource) { $actualListView.ItemsSource } else { $actualListView.Items }
-                if ($null -ne $collectionToUpdate) {
+                # Clear either visible view items only (filtered scope) or the full backing list.
+                $collectionToUpdate = @()
+                if ($tagData.HeaderSelectionAffectsVisibleItemsOnly -and $null -ne $actualListView.ItemsSource) {
+                    $collectionView = [System.Windows.Data.CollectionViewSource]::GetDefaultView($actualListView.ItemsSource)
+                    if ($null -ne $collectionView) {
+                        foreach ($visibleItem in $collectionView) {
+                            $collectionToUpdate += $visibleItem
+                        }
+                    }
+                }
+                elseif ($null -ne $actualListView.ItemsSource) {
+                    $collectionToUpdate = @($actualListView.ItemsSource)
+                }
+                elseif ($actualListView.HasItems) {
+                    $collectionToUpdate = @($actualListView.Items)
+                }
+
+                if ($collectionToUpdate.Count -gt 0) {
                     foreach ($item in $collectionToUpdate) { $item.$($localPropertyName) = $false }
                     $actualListView.Items.Refresh()
                 }
@@ -420,24 +480,38 @@ function Update-SelectAllHeaderCheckBoxState {
         [System.Windows.Controls.CheckBox]$HeaderCheckBox
     )
 
-    $collectionToInspect = $null
-    if ($null -ne $ListView.ItemsSource) {
+    # Determine whether this header should evaluate only visible (filtered) rows.
+    $inspectVisibleItemsOnly = $false
+    if ($null -ne $HeaderCheckBox.Tag -and $null -ne $HeaderCheckBox.Tag.PSObject.Properties['HeaderSelectionAffectsVisibleItemsOnly']) {
+        $inspectVisibleItemsOnly = [bool]$HeaderCheckBox.Tag.HeaderSelectionAffectsVisibleItemsOnly
+    }
+
+    # Build the collection to inspect based on scope (visible view vs full source).
+    $collectionToInspect = @()
+    if ($inspectVisibleItemsOnly -and $null -ne $ListView.ItemsSource) {
+        $collectionView = [System.Windows.Data.CollectionViewSource]::GetDefaultView($ListView.ItemsSource)
+        if ($null -ne $collectionView) {
+            foreach ($visibleItem in $collectionView) {
+                $collectionToInspect += $visibleItem
+            }
+        }
+    }
+    elseif ($null -ne $ListView.ItemsSource) {
         $collectionToInspect = @($ListView.ItemsSource)
     }
     elseif ($ListView.HasItems) {
-        # Check if Items collection has items and ItemsSource is null
         $collectionToInspect = @($ListView.Items)
     }
 
-    # If no items to inspect (either ItemsSource was null and Items was empty, or ItemsSource was empty)
-    if ($null -eq $collectionToInspect -or $collectionToInspect.Count -eq 0) {
+    # If no items are available in the selected scope, force unchecked.
+    if ($collectionToInspect.Count -eq 0) {
         $HeaderCheckBox.IsChecked = $false
         return
     }
 
     $selectedCount = ($collectionToInspect | Where-Object { $_.IsSelected }).Count
     WriteLog "Update-SelectAllHeaderCheckBoxState: Selected count is $selectedCount for ListView '$($ListView.Name)'."
-    $totalItemCount = $collectionToInspect.Count # Get the total count from the collection being inspected
+    $totalItemCount = $collectionToInspect.Count
     WriteLog "Update-SelectAllHeaderCheckBoxState: Total item count is $totalItemCount for ListView '$($ListView.Name)'."
 
     if ($totalItemCount -eq 0) {
@@ -505,21 +579,29 @@ function Invoke-ListViewSort {
         [PSCustomObject]$State
     )
 
+    # Preserve any active CollectionView filter so sorting does not reset a filtered driver model list
+    $existingFilter = $null
+    $existingCollectionView = $null
+    if ($null -ne $listView.ItemsSource) {
+        $existingCollectionView = [System.Windows.Data.CollectionViewSource]::GetDefaultView($listView.ItemsSource)
+        if ($null -ne $existingCollectionView -and $existingCollectionView.Filter) {
+            $existingFilter = $existingCollectionView.Filter
+        }
+    }
+
     # Ensure $State.Flags is a hashtable and contains the required sort properties
     if ($State.Flags -is [hashtable]) {
         if (-not $State.Flags.ContainsKey('lastSortProperty')) {
             $State.Flags['lastSortProperty'] = $null
         }
         if (-not $State.Flags.ContainsKey('lastSortAscending')) {
-            $State.Flags['lastSortAscending'] = $true # Default to ascending
+            $State.Flags['lastSortAscending'] = $true
         }
     }
     else {
         Write-Warning "Invoke-ListViewSort: \$State.Flags is not a hashtable or is null. Sort state may not work correctly."
-        # Attempt to initialize if $State.Flags is null or unexpectedly not a hashtable,
-        # though this might indicate a deeper issue with $State.Flags initialization.
         if ($null -eq $State.Flags) { $State.Flags = @{} }
-        if ($State.Flags -is [hashtable]) { # Check again after potential initialization
+        if ($State.Flags -is [hashtable]) {
             if (-not $State.Flags.ContainsKey('lastSortProperty')) { $State.Flags['lastSortProperty'] = $null }
             if (-not $State.Flags.ContainsKey('lastSortAscending')) { $State.Flags['lastSortAscending'] = $true }
         }
@@ -534,10 +616,15 @@ function Invoke-ListViewSort {
     }
     $State.Flags.lastSortProperty = $property
 
-    # Get items from ItemsSource or Items collection
+    # Build the set of items to sort, enumerating the filtered view if a filter is active
     $currentItemsSource = $listView.ItemsSource
     $itemsToSort = @()
-    if ($null -ne $currentItemsSource) {
+    if ($null -ne $existingCollectionView -and $null -ne $existingFilter) {
+        foreach ($vItem in $existingCollectionView) {
+            $itemsToSort += $vItem
+        }
+    }
+    elseif ($null -ne $currentItemsSource) {
         $itemsToSort = @($currentItemsSource)
     }
     else {
@@ -548,10 +635,11 @@ function Invoke-ListViewSort {
         return
     }
 
+    # Separate selected vs unselected for selected-first ordering
     $selectedItems = @($itemsToSort | Where-Object { $_.IsSelected })
     $unselectedItems = @($itemsToSort | Where-Object { -not $_.IsSelected })
 
-    # Define the primary sort criterion
+    # Define primary sort criterion
     $primarySortDefinition = @{
         Expression = {
             $val = $_.$property
@@ -579,11 +667,11 @@ function Invoke-ListViewSort {
             $secondarySortPropertyName = "Key"
         }
         else {
-            # Default secondary sort for IsSelected or other properties
             $secondarySortPropertyName = "Key"
         }
     }
 
+    # Add secondary sort definition if applicable
     if ($null -ne $secondarySortPropertyName -and $property -ne $secondarySortPropertyName) {
         $itemsHaveSecondaryProperty = $false
         if ($unselectedItems.Count -gt 0) {
@@ -598,35 +686,40 @@ function Invoke-ListViewSort {
         }
 
         if ($itemsHaveSecondaryProperty) {
-            # Create a scriptblock for the secondary sort expression dynamically
             $expressionScriptBlock = [scriptblock]::Create("`$_.$secondarySortPropertyName")
-
             $secondarySortDefinition = @{
                 Expression = {
                     $val = Invoke-Command -ScriptBlock $expressionScriptBlock -ArgumentList $_
                     if ($null -eq $val) { '' } else { $val }
                 }
-                Ascending  = $true # Secondary sort always ascending
+                Ascending  = $true
             }
             $sortCriteria.Add($secondarySortDefinition)
         }
     }
 
+    # Sort unselected items by combined sort criteria
     $sortedUnselected = $unselectedItems | Sort-Object -Property $sortCriteria.ToArray()
-    # Ensure $sortedUnselected is not null before attempting to add its range
     if ($null -eq $sortedUnselected) {
         $sortedUnselected = @()
     }
 
-    # Combine sorted items: selected items first, then sorted unselected items
+    # Merge selected first, then sorted unselected
     $newSortedList = [System.Collections.Generic.List[object]]::new()
     $newSortedList.AddRange($selectedItems)
     $newSortedList.AddRange($sortedUnselected)
 
-    # Set the new sorted list as the ItemsSource
-    # Try nulling out ItemsSource first to force a more complete refresh
+    # Reset ItemsSource and assign sorted list
     $listView.ItemsSource = $null
     $listView.ItemsSource = $newSortedList.ToArray()
+
+    # Reapply preserved filter to maintain the user's filtered view
+    if ($null -ne $existingFilter) {
+        $newView = [System.Windows.Data.CollectionViewSource]::GetDefaultView($listView.ItemsSource)
+        if ($null -ne $newView) {
+            $newView.Filter = $existingFilter
+        }
+    }
 }
 
 # --------------------------------------------------------------------------

FFUDevelopment/FFUUI.Core/FFUUI.Core.WindowsSettings.psm1

@@ -126,7 +126,7 @@ $script:mctWindowsReleases = @(
 
 $script:windowsVersionMap = @{
     10   = @("22H2")
-    11   = @("22H2", "23H2", "24H2")
+    11   = @("25H2", "24H2", "23H2", "22H2")
     2016 = @("1607") # Windows 10 LTSB 2016 & Server 2016
     2019 = @("1809") # Windows 10 LTSC 2019 & Server 2019
     # Note: Server 2016 and LTSB 2016 now share the key 2016, mapping to version "1607"
@@ -268,10 +268,15 @@ function Get-AvailableWindowsVersions {
         # Logic for when an ISO is specified
         $result.Versions = $validVersions
         # Set default selection logic (e.g., latest for Win11)
-        if ($SelectedRelease -eq 11 -and $validVersions -contains "24H2") {
-            $result.DefaultVersion = "24H2"
+        if ($SelectedRelease -eq 11) {
+            if ($validVersions -contains "25H2") {
+                $result.DefaultVersion = "25H2"
+            }
+            elseif ($validVersions -contains "24H2") {
+                $result.DefaultVersion = "24H2"
+            }
         }
-        elseif ($validVersions.Count -gt 0) {
+        if (-not $result.DefaultVersion -and $validVersions.Count -gt 0) {
             $result.DefaultVersion = $validVersions[0]
         }
         $result.IsEnabled = $true
@@ -280,7 +285,7 @@ function Get-AvailableWindowsVersions {
         # Logic for when no ISO is specified (MCT scenario)
         switch ($SelectedRelease) {
             10 { $result.DefaultVersion = "22H2" }
-            11 { $result.DefaultVersion = "24H2" }
+            11 { $result.DefaultVersion = "25H2" }
             # Server versions typically require an ISO, but handle just in case
             2016 { $result.DefaultVersion = "1607" }
             2019 { $result.DefaultVersion = "1809" }
@@ -515,7 +520,7 @@ function Update-WindowsArchCombo {
         }
         else {
             # Standard Windows 11
-            if ($versionValue -eq '24H2') {
+            if ($versionValue -in @('24H2', '25H2')) {
                 $availableArchitectures = @('x64', 'arm64')
             }
             else {

FFUDevelopment/FFUUI.Core/FFUUI.Core.Winget.psm1

@@ -98,10 +98,12 @@ function Save-WingetList {
         $appList = @{
             apps = @($selectedApps | ForEach-Object {
                     [ordered]@{
-                        name         = $_.Name
-                        id           = $_.Id
-                        source       = $_.Source.ToLower()
-                        architecture = $_.Architecture
+                        name                   = (ConvertTo-SafeName -Name $_.Name)
+                        id                     = $_.Id
+                        source                 = $_.Source.ToLower()
+                        architecture           = $_.Architecture
+                        AdditionalExitCodes    = if ($_.PSObject.Properties['AdditionalExitCodes']) { $_.AdditionalExitCodes } else { "" }
+                        IgnoreNonZeroExitCodes = if ($_.PSObject.Properties['IgnoreNonZeroExitCodes']) { [bool]$_.IgnoreNonZeroExitCodes } else { $false }
                     }
                 })
         }
@@ -148,13 +150,15 @@ function Import-WingetList {
                 foreach ($appInfo in $importedAppsData.apps) {
                     $arch = if ($appInfo.source -eq 'msstore') { 'NA' } else { if ($appInfo.PSObject.Properties['architecture']) { $appInfo.architecture } else { $defaultArch } }
                     $newAppListForItemsSource.Add([PSCustomObject]@{
-                            IsSelected     = $true # Imported apps are marked as selected
-                            Name           = $appInfo.name
-                            Id             = $appInfo.id
-                            Version        = ""  # Will be populated when searching or if data exists
-                            Source         = $appInfo.source
-                            Architecture   = $arch
-                            DownloadStatus = ""
+                            IsSelected               = $true # Imported apps are marked as selected
+                            Name                     = $appInfo.name
+                            Id                       = $appInfo.id
+                            Version                  = ""  # Will be populated when searching or if data exists
+                            Source                   = $appInfo.source
+                            Architecture             = $arch
+                            AdditionalExitCodes      = if ($appInfo.PSObject.Properties['AdditionalExitCodes']) { $appInfo.AdditionalExitCodes } else { "" }
+                            IgnoreNonZeroExitCodes   = if ($appInfo.PSObject.Properties['IgnoreNonZeroExitCodes']) { [bool]$appInfo.IgnoreNonZeroExitCodes } else { $false }
+                            DownloadStatus           = ""
                         })
                 }
             }
@@ -191,13 +195,15 @@ function Search-WingetPackagesPublic {
         $output = $results | ForEach-Object -Parallel {
             $arch = if ($_.Source -eq 'msstore') { 'NA' } else { $using:DefaultArchitecture }
             [PSCustomObject]@{
-                IsSelected     = [bool]$false
-                Name           = [string]$_.Name
-                Id             = [string]$_.Id
-                Version        = [string]$_.Version
-                Source         = [string]$_.Source
-                Architecture   = [string]$arch
-                DownloadStatus = [string]::Empty
+                IsSelected               = [bool]$false
+                Name                     = [string]$_.Name
+                Id                       = [string]$_.Id
+                Version                  = [string]$_.Version
+                Source                   = [string]$_.Source
+                Architecture             = [string]$arch
+                AdditionalExitCodes      = [string]::Empty
+                IgnoreNonZeroExitCodes   = [bool]$false
+                DownloadStatus           = [string]::Empty
             }
         } -ThrottleLimit 20
         WriteLog "Winget search completed. Created $($output.Count) output objects."
@@ -372,323 +378,9 @@ function Confirm-WingetInstallationUI {
 
     return $result
 }
-# Function to handle downloading a winget application (Modified for ForEach-Object -Parallel)
-function Start-WingetAppDownloadTask {
-    [CmdletBinding()]
-    param(
-        [Parameter(Mandatory = $true)]
-        [PSCustomObject]$ApplicationItemData, # Pass data, not the UI object
-        [Parameter(Mandatory = $true)]
-        [string]$AppListJsonPath,
-        [Parameter(Mandatory = $true)]
-        [string]$AppsPath, # Pass necessary paths
-        [Parameter(Mandatory = $true)]
-        [string]$OrchestrationPath,
-        [Parameter(Mandatory = $true)]
-        [System.Collections.Concurrent.ConcurrentQueue[hashtable]]$ProgressQueue, # Add queue parameter
-        [string]$WindowsArch
-    )
 
-    $appName = $ApplicationItemData.Name
-    $appId = $ApplicationItemData.Id
-    $source = $ApplicationItemData.Source
-    $status = "Checking..." # Initial local status
-    $resultCode = -1 # Default to error/unknown
-    
-    # Initial status update
-    Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-    
-    WriteLog "Starting download task for $($appName) with ID $($appId) from source $($source)."
-
-    try {
-        # Define paths
-        $userAppListPath = Join-Path -Path $AppsPath -ChildPath "UserAppList.json"
-        $appFound = $false # Flag to track if the app is found locally
-        # WriteLog "UserAppList Path: $($userAppListPath)"
-        # WriteLog "Checking for existing app in UserAppList.json and content folder."
-
-        # 1. Check UserAppList.json and content
-        if (Test-Path -Path $userAppListPath) {
-            # WriteLog "UserAppList.json found at $($userAppListPath). Checking for app entry."
-            try {
-                $userAppListContent = Get-Content -Path $userAppListPath -Raw | ConvertFrom-Json
-                $userAppEntry = $userAppListContent | Where-Object { $_.Name -eq $appName }
-
-                if ($userAppEntry) {
-                    $appFolder = Join-Path -Path "$AppsPath\Win32" -ChildPath $appName
-                    if (Test-Path -Path $appFolder -PathType Container) {
-                        $folderSize = (Get-ChildItem -Path $appFolder -Recurse | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
-                        if ($folderSize -gt 1MB) {
-                            $appFound = $true
-                            $status = "Not Downloaded: App in $userAppListPath and found in $appFolder"
-                            Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-                            WriteLog "Found '$appName' in $userAppListPath and content exists in '$appFolder'."
-                            return [PSCustomObject]@{ Id = $appId; Status = $status; ResultCode = 0 }
-                        }
-                        else {
-                            $appFound = $true
-                            $status = "App in '$userAppListPath' but content missing/small in '$appFolder'. Copy content or remove from UserAppList.json."
-                            Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-                            WriteLog $status
-                            return [PSCustomObject]@{ Id = $appId; Status = $status; ResultCode = 1 }
-                        }
-                    }
-                    else {
-                        $appFound = $true
-                        $status = "App in '$userAppListPath' but content folder '$appFolder' not found. Copy content or remove from UserAppList.json."
-                        Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-                        WriteLog $status
-                        return [PSCustomObject]@{ Id = $appId; Status = $status; ResultCode = 1 }
-                    }
-                }
-            }
-            catch {
-                WriteLog "Warning: Could not read or parse '$userAppListPath'. Error: $($_.Exception.Message)"
-            }
-        }
-
-        # 2. Check existing downloaded Win32 content (folder-based; no WinGetWin32Apps.json dependency)
-        if (-not $appFound -and $source -eq 'winget') {
-            $appFolder = Join-Path -Path "$AppsPath\Win32" -ChildPath $appName
-            if (Test-Path -Path $appFolder -PathType Container) {
-                $contentFound = $false
-                if ($ApplicationItemData.Architecture -eq 'x86 x64') {
-                    $x86Folder = Join-Path -Path $appFolder -ChildPath "x86"
-                    $x64Folder = Join-Path -Path $appFolder -ChildPath "x64"
-                    if ((Test-Path -Path $x86Folder -PathType Container) -and (Test-Path -Path $x64Folder -PathType Container)) {
-                        $x86Size = (Get-ChildItem -Path $x86Folder -Recurse | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
-                        $x64Size = (Get-ChildItem -Path $x64Folder -Recurse | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
-                        if ($x86Size -gt 1MB -and $x64Size -gt 1MB) {
-                            $contentFound = $true
-                        }
-                    }
-                }
-                else {
-                    $folderSize = (Get-ChildItem -Path $appFolder -Recurse | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
-                    if ($folderSize -gt 1MB) {
-                        $contentFound = $true
-                    }
-                }
-                if ($contentFound) {
-                    $appFound = $true
-                    $status = "Not Downloaded: Existing content found in $appFolder"
-                    Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-                    WriteLog "Found existing content for '$appName' in '$appFolder'. Skipping download to prevent duplicate entry."
-                    return [PSCustomObject]@{ Id = $appId; Status = $status; ResultCode = 0 }
-                }
-            }
-        }
-
-        # Check MSStore folder
-        if (-not $appFound -and (Test-Path -Path "$AppsPath\MSStore" -PathType Container)) {
-            $appFolder = Join-Path -Path "$AppsPath\MSStore" -ChildPath $appName
-            if (Test-Path -Path $appFolder -PathType Container) {
-                $folderSize = (Get-ChildItem -Path $appFolder -Recurse | Measure-Object -Property Length -Sum -ErrorAction SilentlyContinue).Sum
-                if ($folderSize -gt 1MB) {
-                    $appFound = $true
-                    $status = "Already downloaded (MSStore)"
-                    Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-                    WriteLog "Found '$appName' content in '$appFolder'."
-                    return [PSCustomObject]@{ Id = $appId; Status = $status; ResultCode = 0 }
-                }
-            }
-        }
-
-        # 3. If not found locally, add to AppList.json and download
-        if (-not $appFound) {
-            # Add to AppList.json
-            $appListContent = $null
-            $appListDir = Split-Path -Path $AppListJsonPath -Parent
-            if (-not (Test-Path -Path $appListDir -PathType Container)) {
-                New-Item -Path $appListDir -ItemType Directory -Force | Out-Null
-            }
-            if (Test-Path -Path $AppListJsonPath) {
-                try {
-                    $appListContent = Get-Content -Path $AppListJsonPath -Raw | ConvertFrom-Json
-                    if (-not $appListContent.PSObject.Properties['apps']) {
-                        $appListContent = @{ apps = @() }
-                    }
-                }
-                catch {
-                    WriteLog "Warning: Could not read or parse '$AppListJsonPath'. Creating new structure. Error: $($_.Exception.Message)"
-                    $appListContent = @{ apps = @() }
-                }
-            }
-            else {
-                $appListContent = @{ apps = @() }
-            }
-
-            $appExistsInAppList = $false
-            if ($appListContent.apps) {
-                foreach ($app in $appListContent.apps) {
-                    if ($app.id -eq $appId) {
-                        $appExistsInAppList = $true
-                        break
-                    }
-                }
-            }
-
-            if (-not $appExistsInAppList) {
-                $newApp = @{ name = $appName; id = $appId; source = $source }
-                if (-not ($appListContent.apps -is [array])) { $appListContent.apps = @() }
-                $appListContent.apps += $newApp
-                try {
-                    # Use a lock to prevent race conditions when writing to the same file
-                    $lockName = "AppListJsonLock"
-                    $lock = New-Object System.Threading.Mutex($false, $lockName)
-                    try {
-                        $lock.WaitOne() | Out-Null
-                        # Re-read content inside lock to ensure latest version
-                        if (Test-Path -Path $AppListJsonPath) {
-                            $currentAppListContent = Get-Content -Path $AppListJsonPath -Raw | ConvertFrom-Json
-                            if (-not ($currentAppListContent.apps | Where-Object { $_.id -eq $appId })) {
-                                $currentAppListContent.apps += $newApp
-                                $currentAppListContent | ConvertTo-Json -Depth 10 | Set-Content -Path $AppListJsonPath -Encoding UTF8
-                                WriteLog "Added '$appName' to '$AppListJsonPath'."
-                            }
-                            else {
-                                WriteLog "'$appName' already exists in '$AppListJsonPath' (checked inside lock)."
-                            }
-                        }
-                        else {
-                            # File doesn't exist, write the initial content
-                            $appListContent | ConvertTo-Json -Depth 10 | Set-Content -Path $AppListJsonPath -Encoding UTF8
-                            WriteLog "Created '$AppListJsonPath' and added '$appName'."
-                        }
-                    }
-                    finally {
-                        $lock.ReleaseMutex()
-                        $lock.Dispose()
-                    }
-                }
-                catch {
-                    WriteLog "Error saving '$AppListJsonPath'. Error: $($_.Exception.Message)"
-                    $status = "Failed to save AppList.json: $($_.Exception.Message)"
-                    Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-                    return [PSCustomObject]@{ Id = $appId; Status = $status; ResultCode = 1 }
-                }
-            }
-            else {
-                WriteLog "'$appName' already exists in '$AppListJsonPath'."
-            }
-
-            # Proceed with download
-            $status = "Downloading..."
-            Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-
-            # Ensure variables needed by Get-Application are accessible
-            # (Assuming they are available via $using: scope or global scope from main script)
-            # $global:AppsPath = $AppsPath # Potentially redundant
-            # $global:WindowsArch = $ApplicationItemData.Architecture # Potentially redundant
-            # $global:orchestrationPath = $OrchestrationPath # Potentially redundant"
-            WriteLog "Orchestration Path: $($OrchestrationPath)"
-            if (-not (Test-Path -Path $OrchestrationPath -PathType Container)) {
-                New-Item -Path $OrchestrationPath -ItemType Directory -Force | Out-Null
-            }
-            $win32Folder = Join-Path -Path $AppsPath -ChildPath "Win32"
-            if ($source -eq "winget" -and -not (Test-Path -Path $win32Folder -PathType Container)) {
-                New-Item -Path $win32Folder -ItemType Directory -Force | Out-Null
-            }
-            $storeAppsFolder = Join-Path -Path $AppsPath -ChildPath "MSStore"
-            if ($source -eq "msstore" -and -not (Test-Path -Path $storeAppsFolder -PathType Container)) {
-                New-Item -Path $storeAppsFolder -ItemType Directory -Force | Out-Null
-            }
-
-            try {
-                # Call Get-Application 
-                $resultCode = Get-Application -AppName $appName -AppId $appId -Source $source -AppsPath $AppsPath -ApplicationArch $ApplicationItemData.Architecture -WindowsArch $WindowsArch -OrchestrationPath $OrchestrationPath -SkipWin32Json -ErrorAction Stop
-
-                # Determine status based on result code
-                switch ($resultCode) {
-                    0 { $status = "Downloaded successfully" }
-                    1 { $status = "Error: No app installers were found" }
-                    2 { $status = "Silent install switch could not be found. Did not download." }
-                    3 { $status = "Error: Publisher does not support download" }
-                    4 { $status = "Skipped: Use 'msstore' source instead." }
-                    default { $status = "Downloaded with status: $resultCode" } # Should not happen with current Get-Application
-                }
-
-                # Remove app from AppList.json if silent install switch could not be found (resultCode 2)
-                if ($resultCode -eq 2) {
-                    try {
-                        if (Test-Path -Path $AppListJsonPath) {
-                            $appListContent = Get-Content -Path $AppListJsonPath -Raw | ConvertFrom-Json
-                            if ($appListContent.apps) {
-                                $filteredApps = @($appListContent.apps | Where-Object { $_.id -ne $appId })
-                                $appListContent.apps = $filteredApps
-                                $appListContent | ConvertTo-Json -Depth 10 | Set-Content -Path $AppListJsonPath -Encoding UTF8
-                                WriteLog "Removed '$appName' ($appId) from '$AppListJsonPath' due to missing silent install switch."
-                            }
-                        }
-                    }
-                    catch {
-                        WriteLog "Failed to remove '$appName' from '$AppListJsonPath': $($_.Exception.Message)"
-                    }
-                }
-            }
-            catch {
-                $status = $_.Exception.Message
-                WriteLog "Download error for $($appName): $($_.Exception.Message)"
-                $resultCode = 1 # Indicate error
-                # Enqueue error status
-                Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-                
-                # Remove app from AppList.json if publisher does not support download
-                if ($_.Exception.Message -match "does not support downloads by the publisher") {
-                    try {
-                        if (Test-Path -Path $AppListJsonPath) {
-                            $appListContent = Get-Content -Path $AppListJsonPath -Raw | ConvertFrom-Json
-                            if ($appListContent.apps) {
-                                $filteredApps = @($appListContent.apps | Where-Object { $_.id -ne $appId })
-                                $appListContent.apps = $filteredApps
-                                $appListContent | ConvertTo-Json -Depth 10 | Set-Content -Path $AppListJsonPath -Encoding UTF8
-                                WriteLog "Removed '$appName' ($appId) from '$AppListJsonPath' due to publisher download restriction."
-                            }
-                        }
-                    }
-                    catch {
-                        WriteLog "Failed to remove '$appName' from '$AppListJsonPath': $($_.Exception.Message)"
-                    }
-                }
-            
-            }
-        } # End if (-not $appFound)
-            
-    }
-    catch {
-        $status = $_.Exception.Message
-        WriteLog "Unexpected error in Start-WingetAppDownloadTask for $($appName): $($_.Exception.Message)"
-        $resultCode = 1 # Indicate error
-        # Enqueue error status
-        Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-    }
-    finally {
-        # Ensure status is not empty before returning
-        if ([string]::IsNullOrEmpty($status)) {
-            $status = "Unknown failure" # Provide a default error status
-            WriteLog "Status was empty for $appName ($appId), setting to default error."
-            if ($resultCode -ne 0 -and $resultCode -ne 1 -and $resultCode -ne 2) {
-                $resultCode = -1 # Ensure resultCode reflects an error if it was empty
-            }
-            # Enqueue the final (error) status if it was previously empty
-            Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-        }
-        elseif ($resultCode -ne 0) {
-            # Enqueue the final status if it's an error (already set in try/catch)
-            Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-        }
-        else {
-            # Enqueue the final success status
-            Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $appId -Status $status
-        }
-    }
-            
-    # Prepare the return object as a Hashtable
-    $returnObject = @{ Id = $appId; Status = $status; ResultCode = $resultCode }
-            
-    # Return the final status and result code as a Hashtable
-    return $returnObject
-}
+# Note: Start-WingetAppDownloadTask has been moved to FFU.Common.Winget.psm1
+# to enable code reuse between UI and CLI builds. It is imported via the FFU.Common module.
 
 function Invoke-WingetDownload {
     param(
@@ -714,15 +406,53 @@ function Invoke-WingetDownload {
         $localOrchestrationPath = Join-Path -Path $State.Controls.txtApplicationPath.Text -ChildPath "Orchestration"
 
         # Create hashtable for task-specific arguments to pass to Invoke-ParallelProcessing
+        # UI downloads skip WinGetWin32Apps.json creation - it's generated at build time
         $taskArguments = @{
             AppsPath            = $localAppsPath
             AppListJsonPath     = $localAppListJsonPath
             OrchestrationPath   = $localOrchestrationPath
             WindowsArch         = $localWindowsArch
+            SkipWin32Json       = $true
         }
 
         # Select only necessary properties before passing to Invoke-ParallelProcessing
         $itemsToProcess = $selectedApps | Select-Object Name, Id, Source, Version, Architecture # Include Version and Architecture if needed
+
+        # Before downloading, persist the selected apps to AppList.json including exit-code fields (parity with Save-WingetList)
+        try {
+            # Determine AppList.json path; default if empty
+            if ([string]::IsNullOrWhiteSpace($localAppListJsonPath)) {
+                $localAppListJsonPath = Join-Path -Path $localAppsPath -ChildPath "AppList.json"
+                $taskArguments.AppListJsonPath = $localAppListJsonPath
+                WriteLog "AppListJsonPath was empty. Defaulting to: $localAppListJsonPath"
+            }
+
+            # Build apps payload from current selection, preserving AdditionalExitCodes/IgnoreNonZeroExitCodes
+            $appListToSave = @{
+                apps = @($selectedApps | ForEach-Object {
+                        [ordered]@{
+                            name                   = (ConvertTo-SafeName -Name $_.Name)
+                            id                     = $_.Id
+                            source                 = $_.Source.ToLower()
+                            architecture           = $_.Architecture
+                            AdditionalExitCodes    = if ($_.PSObject.Properties['AdditionalExitCodes']) { $_.AdditionalExitCodes } else { "" }
+                            IgnoreNonZeroExitCodes = if ($_.PSObject.Properties['IgnoreNonZeroExitCodes']) { [bool]$_.IgnoreNonZeroExitCodes } else { $false }
+                        }
+                    })
+            }
+
+            # Ensure destination directory exists and write AppList.json
+            $destDir = Split-Path -Parent $localAppListJsonPath
+            if (-not (Test-Path -LiteralPath $destDir)) {
+                [void][System.IO.Directory]::CreateDirectory($destDir)
+            }
+            $appListToSave | ConvertTo-Json -Depth 10 | Set-Content -Path $localAppListJsonPath -Encoding UTF8
+            WriteLog "Persisted AppList.json with selected apps and exit-code fields to: $localAppListJsonPath"
+        }
+        catch {
+            WriteLog "Warning: Failed to persist AppList.json prior to download. Error: $($_.Exception.Message)"
+        }
+
         # Invoke the centralized parallel processing function
         # Pass task type and task-specific arguments
         Invoke-ParallelProcessing -ItemsToProcess $itemsToProcess `

FFUDevelopment/FFUUI.Core/FFUUI.Core.psm1

@@ -117,6 +117,7 @@ function Get-GeneralDefaults {
         ShareName                      = "FFUCaptureShare"
         Username                       = "ffu_user"
         Threads                        = 5
+        BitsPriority                   = 'Normal'
         MaxUSBDrives                   = 5
         BuildUSBDriveEnable            = $false
         CompactOS                      = $true
@@ -128,6 +129,7 @@ function Get-GeneralDefaults {
         AllowExternalHardDiskMedia     = $false
         PromptExternalHardDiskMedia    = $true
         SelectSpecificUSBDrives        = $false
+        CopyAdditionalFFUFiles         = $false
         CopyAutopilot                  = $false
         CopyUnattend                   = $false
         CopyPPKG                       = $false
@@ -139,9 +141,10 @@ function Get-GeneralDefaults {
         RemoveFFU                      = $false
         RemoveApps                     = $false 
         RemoveUpdates                  = $false 
+        RemoveDownloadedESD            = $true
         # Hyper-V Settings Defaults
         VMHostIPAddress                = ""
-        DiskSizeGB                     = 30
+        DiskSizeGB                     = 50
         MemoryGB                       = 4
         Processors                     = 4
         VMLocation                     = $vmLocationPath
@@ -175,25 +178,101 @@ function Get-GeneralDefaults {
         InstallDrivers                 = $false
         CopyDrivers                    = $false
         CopyPEDrivers                  = $false
+        UseDriversAsPEDrivers          = $false
         UpdateADK                      = $true
         CompressDownloadedDriversToWim = $false
     }
 }
 
 # Function to get USB Drives (Moved from BuildFFUVM_UI.ps1)
+# Uses Get-Disk to retrieve UniqueId which is more reliable than SerialNumber
+# UniqueId is trimmed to remove the machine name suffix (characters after colon)
 function Get-USBDrives {
     Get-WmiObject Win32_DiskDrive | Where-Object {
         ($_.MediaType -eq 'Removable Media' -or $_.MediaType -eq 'External hard disk media')
     } | ForEach-Object {
         $size = [math]::Round($_.Size / 1GB, 2)
-        $serialNumber = if ($_.SerialNumber) { $_.SerialNumber.Trim() } else { "N/A" }
-        @{
-            IsSelected   = $false
-            Model        = $_.Model.Trim()
-            SerialNumber = $serialNumber
-            Size         = $size
-            DriveIndex   = $_.Index
+        # Get the disk using the index to retrieve UniqueId
+        $disk = Get-Disk -Number $_.Index -ErrorAction SilentlyContinue
+        # Trim the machine name suffix (everything after the colon) from UniqueId
+        $uniqueId = if ($disk -and $disk.UniqueId) {
+            $rawId = $disk.UniqueId
+            if ($rawId -match ':') {
+                $rawId.Split(':')[0]
+            }
+            else {
+                $rawId
+            }
         }
+        else {
+            "N/A"
+        }
+        @{
+            IsSelected = $false
+            Model      = $_.Model.Trim()
+            UniqueId   = $uniqueId
+            Size       = $size
+            DriveIndex = $_.Index
+        }
+    }
+}
+
+# Returns a list of FFU files from the provided folder with selection metadata
+function Get-FFUFiles {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [string]$Path
+    )
+    if (-not (Test-Path -Path $Path)) {
+        return @()
+    }
+    Get-ChildItem -Path $Path -Filter '*.ffu' -File -ErrorAction SilentlyContinue | ForEach-Object {
+        [PSCustomObject]@{
+            IsSelected   = $false
+            Name         = $_.Name
+            LastModified = $_.LastWriteTime
+            FullName     = $_.FullName
+        }
+    }
+}
+
+# Helper: Populate Additional FFU List from the capture folder
+function Update-AdditionalFFUList {
+    [CmdletBinding()]
+    param(
+        [Parameter(Mandatory = $true)]
+        [PSCustomObject]$State
+    )
+    try {
+        $ffuFolder = $State.Controls.txtFFUCaptureLocation.Text
+        $listView = $State.Controls.lstAdditionalFFUs
+        if ($null -eq $listView) { return }
+        $listView.Items.Clear()
+        if ([string]::IsNullOrWhiteSpace($ffuFolder) -or -not (Test-Path -Path $ffuFolder)) {
+            WriteLog "Additional FFUs: Capture folder not set or not found: $ffuFolder"
+        }
+        else {
+            $items = Get-ChildItem -Path $ffuFolder -Filter '*.ffu' -File -ErrorAction SilentlyContinue |
+                Sort-Object LastWriteTime -Descending |
+                ForEach-Object {
+                    [PSCustomObject]@{
+                        IsSelected   = $false
+                        Name         = $_.Name
+                        LastModified = $_.LastWriteTime
+                        FullName     = $_.FullName
+                    }
+                }
+            foreach ($it in $items) { $listView.Items.Add($it) | Out-Null }
+            WriteLog "Additional FFUs: Found $($listView.Items.Count) FFU files in $ffuFolder."
+        }
+        $headerChk = $State.Controls.chkSelectAllAdditionalFFUs
+        if ($null -ne $headerChk) {
+            Update-SelectAllHeaderCheckBoxState -ListView $listView -HeaderCheckBox $headerChk
+        }
+    }
+    catch {
+        WriteLog "Update-AdditionalFFUList error: $($_.Exception.Message)"
     }
 }
 
@@ -242,6 +321,23 @@ function Update-ApplicationPanelVisibility {
     }
 }
 
+# Function to identify whether current Windows release selection is Windows 10 LTSB/LTSC
+function Test-IsWindows10LtscReleaseSelection {
+    param([PSCustomObject]$State)
+
+    $releaseItem = $State.Controls.cmbWindowsRelease.SelectedItem
+    if ($null -eq $releaseItem) {
+        return $false
+    }
+
+    $releaseDisplay = [string]$releaseItem.Display
+    if ([string]::IsNullOrWhiteSpace($releaseDisplay)) {
+        return $false
+    }
+
+    return (($releaseDisplay -like 'Windows 10*') -and (($releaseDisplay -like '*LTSB*') -or ($releaseDisplay -like '*LTSC*')))
+}
+
 # Function to manage the state of the main "Install Apps" checkbox based on selections in Updates/Office
 function Update-InstallAppsState {
     param([PSCustomObject]$State)
@@ -249,11 +345,16 @@ function Update-InstallAppsState {
     $installAppsChk = $State.Controls.chkInstallApps
     $installOfficeChk = $State.Controls.chkInstallOffice
 
+    # Determine if Windows 10 LTSB/LTSC + Update Latest CU is selected
+    $isWindows10LtscRelease = Test-IsWindows10LtscReleaseSelection -State $State
+    $isLtscCuChecked = $State.Controls.chkUpdateLatestCU.IsChecked -and $isWindows10LtscRelease
+
     # Determine if any checkbox that forces "Install Apps" is checked
     $anyUpdateChecked = $State.Controls.chkUpdateLatestDefender.IsChecked -or `
         $State.Controls.chkUpdateEdge.IsChecked -or `
         $State.Controls.chkUpdateOneDrive.IsChecked -or `
-        $State.Controls.chkUpdateLatestMSRT.IsChecked
+        $State.Controls.chkUpdateLatestMSRT.IsChecked -or `
+        $isLtscCuChecked
     
     $isForced = $anyUpdateChecked -or $installOfficeChk.IsChecked
 
@@ -292,11 +393,14 @@ function Update-DriverCheckboxStates {
     $installDriversChk = $State.Controls.chkInstallDrivers
     $copyDriversChk = $State.Controls.chkCopyDrivers
     $compressWimChk = $State.Controls.chkCompressDriversToWIM
+    $copyPEDriversChk = $State.Controls.chkCopyPEDrivers
+    $useDriversAsPeChk = $State.Controls.chkUseDriversAsPEDrivers
 
     # Default to enabled, then apply disabling rules
     $installDriversChk.IsEnabled = $true
     $copyDriversChk.IsEnabled = $true
     $compressWimChk.IsEnabled = $true
+    $copyPEDriversChk.IsEnabled = $true
 
     if ($installDriversChk.IsChecked) {
         $copyDriversChk.IsEnabled = $false
@@ -310,6 +414,16 @@ function Update-DriverCheckboxStates {
     if ($compressWimChk.IsChecked) {
         $installDriversChk.IsEnabled = $false
     }
+
+    # Sub-option visibility logic: only show UseDriversAsPEDrivers when CopyPEDrivers is checked
+    if ($copyPEDriversChk.IsChecked) {
+        $useDriversAsPeChk.Visibility = 'Visible'
+    }
+    else {
+        # Parent unchecked: hide and clear sub-option
+        $useDriversAsPeChk.IsChecked = $false
+        $useDriversAsPeChk.Visibility = 'Collapsed'
+    }
 }
 
 # Function to manage the visibility of Office UI panels

FFUDevelopment/USBImagingToolCreator.ps1

@@ -28,7 +28,7 @@ function Write-ProgressLog {
     }
 Function Get-RemovableDrive {
 writelog "Get information for all removable drives"
-$USBDrives = Get-WmiObject Win32_DiskDrive | Where-Object {$_.MediaType -eq "Removable media"} 
+$USBDrives = Get-WmiObject Win32_DiskDrive | Where-Object {$_.MediaType -eq "Removable media" -or $_.MediaType -eq "External hard disk media"} 
 If($USBDrives -and ($null -eq $USBDrives.count)) {
         $USBDrivesCount = 1
     } else {
@@ -62,6 +62,7 @@ Function Build-DeploymentUSB{
             $ScriptBlock = {
             param($DriveNumber)
             Clear-Disk -Number $DriveNumber -RemoveData -RemoveOEM -Confirm:$false
+			Initialize-Disk -Number $DriveNumber
             $Disk = Get-Disk -Number $DriveNumber
             $PartitionStyle = $Disk.PartitionStyle
             if($PartitionStyle -ne 'MBR'){
@@ -120,13 +121,6 @@ $Destination = $Drive + ":\"
     Start-Job -ScriptBlock $jobScriptBlock -ArgumentList $ImagesPath, $Destination | Out-Null
     }
 }
-if(!($Images)){
-    foreach ($Drive in $DeployDrives) {
-        WriteLog "Create images directory"
-        $drivepath = $Drive + ":\"
-        New-Item -Path "$drivepath" -Name Images -ItemType Directory -Force -Confirm: $false | Out-Null
-        }
-}
 if($Drivers){
 writelog "Copying driver files to all drives labeled deploy concurrently"
 foreach ($Drive in $DeployDrives) {

README.md

@@ -1,3 +1,9 @@
+# Updates
+
+## 2026-03-16 - [2603.2 Released](https://github.com/rbalsleyMSFT/FFU/releases)
+
+Fixes an issue with devices not booting after applying an FFU. Highly recommended you update today. 
+
 # Using Full Flash Update (FFU) files to speed up Windows deployment
 
 What if you could have a Windows image (Windows 10/11/Server/LTSC) that has:
@@ -18,88 +24,14 @@ And the best part: **it takes less than two minutes** to apply the image, even w
 
 The Full-Flash update (FFU) process can automatically download the latest release of Windows 11, the updates mentioned above, and creates a USB drive that can be used to quickly reimage a machine.
 
-# Updates
-
-2507.1 has been released to preview! This is a major update that brings a new user interface to preview.
-
-Docs are coming, but will take a bit to write them. The youtube video is a must watch for a complete demo on how to use the UI and the changes made to apps (InstallAppsAndSysprep.cmd is gone) and drivers. I'll be recording a more formalized deep dive with slides that go a bit deeper into how things work, but the UI walkthrough should get most people going.
-
 # Getting Started
 
-- Download the latest [release](https://github.com/rbalsleyMSFT/FFU/releases)
-- Extract the FFUDevelopment folder from the ZIP file (recommend to C:\FFUDevelopment)
-- Watch the Youtube video (updated docs for the UI coming soon)
+If you're new to FFU Builder or new to the FFU Builder UI version, check out the [Quick Start Guide](https://rbalsleymsft.github.io/FFU/quickstart.html).
 
-## YouTube Detailed Walkthrough
+This will be the fastest way to create your first FFU. There's a new [FFU Builder Quickstart Youtube video](https://youtu.be/kOIK5OmDugc) based on the 2602.1 UI Preview release.
 
-Here's a detailed overview of the new UI process. 
+## Older Youtube Videos
 
-[![Reimage Windows Fast with FFU Builder 2507.1 Preview](https://img.youtube.com/vi/oozG1aVcg9M/maxresdefault.jpg)](https://youtu.be/oozG1aVcg9M "Reimage Windows Fast with FFU Builder 2507.1 Preview")
+[2507.1 UI Preview Video](https://www.youtube.com/watch?v=oozG1aVcg9M) - First UI Preview release video. This goes deeper than the quick start video, but is missing some features that have been added since 2507.1 was released.
 
-Chapters:
-
-[00:00](https://www.youtube.com/watch?v=oozG1aVcg9M&t=0s) Begin
-
-[01:07](https://www.youtube.com/watch?v=oozG1aVcg9M&t=67s) Prereqs
-
-[06:32](https://www.youtube.com/watch?v=oozG1aVcg9M&t=392s) Demo Begins
-
-[07:16](https://www.youtube.com/watch?v=oozG1aVcg9M&t=436s) Running the BuildFFUVM_UI.ps1 script
-
-[08:15](https://www.youtube.com/watch?v=oozG1aVcg9M&t=495s) UI Overview
-
-[10:13](https://www.youtube.com/watch?v=oozG1aVcg9M&t=613s) Hyper-V Settings
-
-[16:04](https://www.youtube.com/watch?v=oozG1aVcg9M&t=964s) Windows Settings
-
-[22:35](https://www.youtube.com/watch?v=oozG1aVcg9M&t=1355s) Updates
-
-[24:49](https://www.youtube.com/watch?v=oozG1aVcg9M&t=1489s) Applications
-
-[29:39](https://www.youtube.com/watch?v=oozG1aVcg9M&t=1779s) Install Winget Applications
-
-[45:29](https://www.youtube.com/watch?v=oozG1aVcg9M&t=2729s) Bring Your Own Applications
-
-[54:14](https://www.youtube.com/watch?v=oozG1aVcg9M&t=3254s) Apps Script Variables
-
-[57:43](https://www.youtube.com/watch?v=oozG1aVcg9M&t=3463s) M365 Apps/Office
-
-[59:01](https://www.youtube.com/watch?v=oozG1aVcg9M&t=3541s) Drivers
-
-[01:01:22](https://www.youtube.com/watch?v=oozG1aVcg9M&t=3682s) Drivers.json example
-
-[01:02:07](https://www.youtube.com/watch?v=oozG1aVcg9M&t=3727s) DriverMapping.json explanation
-
-[01:06:08](https://www.youtube.com/watch?v=oozG1aVcg9M&t=3968s) Driver WIM Compression
-
-[01:10:50](https://www.youtube.com/watch?v=oozG1aVcg9M&t=4250s) Build
-
-[01:12:41](https://www.youtube.com/watch?v=oozG1aVcg9M&t=4361s) Build USB Drive
-
-[01:20:07](https://www.youtube.com/watch?v=oozG1aVcg9M&t=4807s) Monitor
-
-[01:20:32](https://www.youtube.com/watch?v=oozG1aVcg9M&t=4832s) Setting up the Demo Build
-
-[01:24:10](https://www.youtube.com/watch?v=oozG1aVcg9M&t=5050s) Save/Load Config Files
-
-[01:25:11](https://www.youtube.com/watch?v=oozG1aVcg9M&t=5111s) Kicking off the Demo Build/Going over the monitor tab
-
-[01:32:26](https://www.youtube.com/watch?v=oozG1aVcg9M&t=5546s) Demoing the new FFU Builder Orchestrator
-
-[01:35:25](https://www.youtube.com/watch?v=oozG1aVcg9M&t=5725s) New captureffu.ps1 console output
-
-[01:42:29](https://www.youtube.com/watch?v=oozG1aVcg9M&t=6149s) Demo Build Complete
-
-[01:42:42](https://www.youtube.com/watch?v=oozG1aVcg9M&t=6162s) How to configure a VM to test your newly built FFU
-
-[01:48:58](https://www.youtube.com/watch?v=oozG1aVcg9M&t=6538s) The moment of truth: What does the new deployment experience look like?
-
-[01:53:13](https://www.youtube.com/watch?v=oozG1aVcg9M&t=6793s) How to bypass OOBE using a provisioning package
-
-[01:55:49](https://www.youtube.com/watch?v=oozG1aVcg9M&t=6949s) Preview Focus Areas
-
-[02:04:04](https://www.youtube.com/watch?v=oozG1aVcg9M&t=7444s) Known Issues/Things to fix before GA
-
-[02:05:38](https://www.youtube.com/watch?v=oozG1aVcg9M&t=7538s) Providing Feedback
-
-[02:06:43](https://www.youtube.com/watch?v=oozG1aVcg9M&t=7603s) Thank you
+[2407.2 Video](https://www.youtube.com/watch?v=rqXRbgeeKSQ) - This was the main deep-dive video on FFU Builder (before it had that name). This is a good deep dive into how the BuildFFUVM.ps1 script works, but a lot has changed since that build.

docs/M365appsoffice.md

@@ -0,0 +1,69 @@
+---
+title: M365 Apps/Office
+nav_order: 8
+prev_url: /appsscriptvariables.html
+prev_label: Apps Script Variables
+next_url: /drivers.html
+next_label: Drivers
+parent: UI Overview
+---
+# M365 Apps/Office
+
+![1760378889283](image/appsscriptvariablescopy/1760378889283.png)
+
+FFU Builder uses the Office Deployment Toolkit (ODT) to install Office. In the `.\FFUDevelopment\Apps\Office` folder you'll find two files:
+
+* `DownloadFFU.xml`
+* `DeployFFU.xml`
+
+## DownloadFFU.xml
+
+`DownloadFFU.xml` is responsible for the download of Office. It's invoked by `setup.exe /download .\DownloadFFU.xml` during the build process. It defaults to downloading the current channel 64-bit version of Office matching the current OS language to `C:\FFUDevelopment\Apps\Office`.
+
+`DownloadFFU.xml` contents:
+
+```
+<Configuration ID="efa6df21-a106-428e-8eaa-d89a5dda6030">
+  <Add SourcePath="C:\FFUDevelopment\Apps\Office" OfficeClientEdition="64" Channel="Current">
+    <Product ID="O365ProPlusRetail">
+      <Language ID="MatchOS" />
+    </Product>
+  </Add>
+</Configuration>
+```
+
+If you want to modify the language, you'll need to change the language ID to the language you wish to download and install.
+
+For more information about deploying languages see: [Overview of deploying languages for Microsoft 365 Apps - Microsoft 365 Apps Microsoft Learn](https://learn.microsoft.com/en-us/microsoft-365-apps/deploy/overview-deploying-languages-microsoft-365-apps)
+
+## DeployFFU.xml
+
+`DeployFFU.xml` is responsible for customizing the installation of Office. If you don't provide a custom XML, it will default to using what's in `DeployFFU.xml`. The default configuration will install the 64-bit current channel version of Office with Word, Excel, Powerpoint. Below is what's currently in `DeployFFU.xml`:
+
+```
+<Configuration ID="efa6df21-a106-428e-8eaa-d89a5dda6030">
+  <Add OfficeClientEdition="64" Channel="Current">
+    <Product ID="O365ProPlusRetail">
+      <Language ID="MatchOS" />
+      <ExcludeApp ID="Access" />
+      <ExcludeApp ID="Lync" />
+      <ExcludeApp ID="Publisher" />
+      <ExcludeApp ID="Bing" />
+      <ExcludeApp ID="Teams" />
+      <ExcludeApp ID="Outlook" />
+    </Product>
+  </Add>
+  <Property Name="SharedComputerLicensing" Value="0" />
+  <Property Name="FORCEAPPSHUTDOWN" Value="FALSE" />
+  <Property Name="DeviceBasedLicensing" Value="0" />
+  <Property Name="SCLCacheOverride" Value="0" />
+  <Updates Enabled="TRUE" />
+  <Display Level="None" AcceptEULA="TRUE" />
+</Configuration>
+```
+
+## Copy Office Configuration XML
+
+If you want to include your own custom XML file for office, check **Copy Office Configuration XML** and browse to the location of your custom XML file. The path to your custom Office configuration XML file is stored in the `OfficeConfigXMLFile` parameter. This file gets added to the `.\FFUDevelopment\Apps\Office` folder and is referenced in the `.\FFUDevelopment\Apps\Orchestration\Install-Office.ps1` file. 
+
+{% include page_nav.html %}

docs/_config.yml

@@ -0,0 +1,25 @@
+title: FFU Builder
+description: Build and deploy Windows FFU images
+remote_theme: just-the-docs/just-the-docs@v0.10.1
+plugins:
+  - jekyll-remote-theme
+  - jekyll-seo-tag
+
+search_enabled: true
+
+# Canonical host for absolute URLs (sitemap/robots/canonical tags)
+url: "https://rbalsleymsft.github.io"
+
+# Because you’ll publish as a project site at /FFU
+baseurl: "/FFU"
+
+callouts:
+  note:
+    title: Note
+    color: purple
+  tip:
+    title: Tip
+    color: green
+  warning:
+    title: Warning
+    color: yellow

docs/_includes/head_custom.html

@@ -0,0 +1,292 @@
+{% if page.url == '/' or page.url == '/index.html' %}
+<meta name="google-site-verification" content="2O8GqDcQF_fvyvZjeTz-YlTaN2p62FfWd9w-xHU4Zbc" />
+{% endif %}
+{% if page.url == '/' or page.url == '/index.html' %}
+<meta name="google-site-verification" content="2O8GqDcQF_fvyvZjeTz-YlTaN2p62FfWd9w-xHU4Zbc" />
+{% endif %}
+<!-- docs/_includes/head_custom.html -->
+<style>
+    /* Layout: remove Just-the-Docs "centered narrow" constraints on wide screens */
+    @media (min-width: 50rem) {
+        .main {
+            max-width: none !important;
+        }
+    }
+
+    @media (min-width: 66.5rem) {
+        .side-bar {
+            width: 16.5rem !important;
+            min-width: 16.5rem !important;
+        }
+
+        .side-bar+.main {
+            margin-left: 16.5rem !important;
+        }
+    }
+
+    /* Readability: wider column + slightly larger, less-thin text */
+    @media (min-width: 66.5rem) {
+        .main-content {
+            max-width: 1100px;
+        }
+    }
+
+    @media (min-width: 90rem) {
+        .main-content {
+            max-width: 1280px;
+        }
+    }
+
+    /* Typography: approximate Microsoft Learn (Segoe UI Variable + regular body + semibold headings) */
+    body,
+    .main-content {
+        font-family: "Segoe UI Variable Text", "Segoe UI Variable", "Segoe UI", system-ui, -apple-system, "Helvetica Neue", Arial, sans-serif;
+        -webkit-font-smoothing: antialiased;
+        -moz-osx-font-smoothing: grayscale;
+        text-rendering: optimizeLegibility;
+    }
+
+    .main-content {
+        margin-right: auto;
+        margin-left: auto;
+        font-size: 1rem;
+        /* 16px-ish, closer to Learn */
+        line-height: 1.6;
+        font-weight: 400;
+
+        /* Just-the-Docs defaults body text to a mid-grey; make it closer to Learn */
+        color: #242424;
+    }
+
+    .main-content p,
+    .main-content li {
+        line-height: 1.65;
+    }
+
+    /* Lists: increase indentation (Learn-like) */
+    /* Just-the-Docs draws bullets/numbers via ::before with negative offsets */
+    .main-content ul,
+    .main-content ol {
+        padding-left: 2.25em;
+    }
+
+    .main-content h1,
+    .main-content h2,
+    .main-content h3 {
+        font-weight: 600;
+        letter-spacing: -0.01em;
+    }
+
+    .main-content code,
+    .main-content pre code {
+        font-size: 0.95em;
+    }
+
+    /* Wrapping: prevent long code/paths from overflowing into the page TOC */
+    .main-content {
+        overflow-wrap: anywhere;
+        word-break: break-word;
+    }
+
+    .main-content :not(pre)>code {
+        white-space: normal;
+        overflow-wrap: anywhere;
+        word-break: break-word;
+    }
+
+    .main-content a {
+        overflow-wrap: anywhere;
+        word-break: break-word;
+    }
+
+    /* Images: make it obvious they're zoomable (opt-out via class="no-zoom") */
+    .main-content img:not(.no-zoom) {
+        cursor: zoom-in;
+    }
+
+    /* Image zoom: ensure the zoom overlay sits above the right TOC */
+    .medium-zoom-overlay {
+        z-index: 9999 !important;
+    }
+
+    .medium-zoom-image--opened {
+        z-index: 10000 !important;
+    }
+
+    /* Right-side page TOC (desktop only) */
+    @media (min-width: 66.5rem) {
+        .main-content-wrap.has-page-toc {
+            display: grid;
+            grid-template-columns: minmax(0, 1fr) 16rem;
+            grid-template-rows: auto 1fr;
+            grid-template-areas:
+                "breadcrumb breadcrumb"
+                "content toc";
+            column-gap: 2rem;
+            align-items: start;
+        }
+
+        /* Breadcrumbs (when present) always span full width */
+        .main-content-wrap.has-page-toc .breadcrumb-nav {
+            grid-area: breadcrumb;
+        }
+
+        /* Main content always stays in the left column */
+        .main-content-wrap.has-page-toc .main-content {
+            grid-area: content;
+
+            /* Prevent wide tables/code from forcing overlap */
+            min-width: 0;
+
+            /* Force the content to respect the grid column width (no centering/max-width overflow) */
+            width: 100%;
+            max-width: 100%;
+            margin-left: 0;
+            margin-right: 0;
+            justify-self: stretch;
+
+            /* Keep heading permalink icons visible */
+            /* (Just-the-Docs positions .anchor-heading to the left at desktop widths) */
+            overflow-x: visible;
+        }
+
+        /* Safety net: prevent long code/tables from overlapping the TOC */
+        .main-content-wrap.has-page-toc .main-content pre,
+        .main-content-wrap.has-page-toc .main-content .highlighter-rouge,
+        .main-content-wrap.has-page-toc .main-content .table-wrapper {
+            overflow-x: auto;
+        }
+
+        /* TOC always stays in the right column */
+        .page-toc {
+            grid-area: toc;
+            position: sticky;
+            top: 5.5rem;
+            max-height: calc(100vh - 6.5rem);
+            overflow: auto;
+            padding-left: 1rem;
+            border-left: 1px solid #eeebee;
+            font-size: 0.875rem;
+
+            /* Ensure the TOC doesn’t visually blend with overflowing content */
+            background-color: #fff;
+            z-index: 1;
+        }
+
+        .page-toc__title {
+            font-weight: 600;
+            color: #27262b;
+            margin-bottom: 0.75rem;
+        }
+
+        .page-toc__list {
+            list-style: none;
+            padding-left: 0;
+            margin: 0;
+        }
+
+        .page-toc__item {
+            margin: 0.4rem 0;
+        }
+
+        .page-toc__item--h3 {
+            padding-left: 0.75rem;
+        }
+
+        .page-toc__link {
+            color: inherit;
+            text-decoration: none;
+            display: block;
+            padding: 0.125rem 0 0.125rem 0.75rem;
+            border-left: 3px solid transparent;
+        }
+
+        .page-toc__link:hover {
+            text-decoration: underline;
+        }
+
+                .page-toc__link.is-active {
+                    font-weight: 600;
+                    color: #1a1a1a;
+                    border-left-color: #2563eb;
+                }
+            }
+        
+            /* Inline "In this article" TOC (narrow viewports; Learn-like) */
+            .page-toc.page-toc--inline {
+                margin: 1.5rem 0;
+                padding-left: 1rem;
+                border-left: 1px solid #eeebee;
+                font-size: 0.875rem;
+            }
+        
+            .page-toc--inline .page-toc__title {
+                font-weight: 600;
+                color: #27262b;
+                margin-bottom: 0.75rem;
+            }
+        
+            .page-toc--inline .page-toc__list {
+                list-style: none !important;
+                padding-left: 0;
+                margin: 0;
+            }
+        
+            .page-toc--inline .page-toc__item {
+                list-style: none !important;
+                margin: 0.4rem 0;
+            }
+
+            .page-toc--inline .page-toc__item::marker {
+                content: "";
+            }
+        
+            .page-toc--inline .page-toc__item--h3 {
+                padding-left: 0.75rem;
+            }
+        
+            .page-toc--inline .page-toc__link {
+                color: inherit;
+                text-decoration: none;
+                display: block;
+                padding: 0.125rem 0 0.125rem 0.75rem;
+                border-left: 3px solid transparent;
+            }
+        
+            .page-toc--inline .page-toc__link:hover {
+                text-decoration: underline;
+            }
+        
+            .page-toc__item.is-hidden {
+                display: none;
+            }
+
+            /* Just-the-Docs renders UL bullets via li::before; disable for inline TOC */
+            .page-toc--inline ul > li::before,
+            .page-toc--inline .page-toc__list > li::before,
+            .page-toc--inline .page-toc__item::before {
+                content: "" !important;
+                display: none !important;
+            }
+        
+            .page-toc__toggle {
+                background: none;
+                border: 0;
+                padding: 0.25rem 0 0 0.75rem;
+                font: inherit;
+                color: inherit;
+                cursor: pointer;
+                text-decoration: none;
+            }
+        
+            .page-toc__toggle:hover {
+                text-decoration: underline;
+            }
+        </style>
+
+<meta name="ffu-right-toc" content="{% if page.right_toc == false %}false{% else %}true{% endif %}">
+
+<script src="{{ '/assets/js/vendor/medium-zoom.min.js' | relative_url }}" defer></script>
+<script src="{{ '/assets/js/image-zoom.js' | relative_url }}" defer></script>
+<script src="{{ '/assets/js/page-toc.js' | relative_url }}" defer></script>
+<script src="{{ '/assets/js/external-links.js' | relative_url }}" defer></script>

docs/_includes/page_nav.html

@@ -0,0 +1,17 @@
+<!-- docs/_includes/page_nav.html -->
+<div class="d-flex flex-justify-between mt-6">
+  {% assign prev_url   = include.prev_url  | default: page.prev_url %}
+  {% assign prev_label = include.prev_label| default: page.prev_label | default: 'Home' %}
+  {% assign next_url   = include.next_url  | default: page.next_url %}
+  {% assign next_label = include.next_label| default: page.next_label | default: 'Next' %}
+
+  {% if prev_url %}
+    <a class="btn btn-outline" href="{{ prev_url | relative_url }}">← {{ prev_label }}</a>
+  {% else %}
+    <span></span>
+  {% endif %}
+
+  {% if next_url %}
+    <a class="btn btn-blue" href="{{ next_url | relative_url }}">{{ next_label }} →</a>
+  {% endif %}
+</div>

docs/applications.md

@@ -0,0 +1,21 @@
+---
+title: Applications 
+nav_order: 4
+prev_url: /updates.html
+prev_label: Updates
+next_url: /winget.html
+next_label: Install Winget Applications
+parent: UI Overview
+has_toc: false
+---
+# Applications
+
+![1759881364454](image/updatescopy/1759881364454.png)
+
+Applications can be installed in three different ways:
+
+* Winget (using an AppList.json file)
+* Bring Your Own Applications (using files you provide - can also be used to run command lines with or without content)
+* Apps Script Variables (key/value pairs used in conjunction with a PowerShell script to install custom applications)
+
+{% include page_nav.html %}

docs/appsscriptvariables.md

@@ -0,0 +1,138 @@
+---
+title: Apps Script Variables
+nav_order: 7
+prev_url: /byoapps.html
+prev_label: BYO Applications
+next_url: /M365appsoffice.html
+next_label: M365 Apps Office
+parent: Applications
+grand_parent: UI Overview
+---
+# Apps Script Variables
+
+![1760135511234](image/appsscriptvariables/1760135511234.png)
+
+Apps Script Variables are key value pairs that are used to create a hashtable that is passed to the `BuildFFUVM.ps1` script (stored in the `$AppScriptVariables` parameter as a hashtable). At build time, `BuildFFUVM.ps1` will export the `$AppsScriptVariables` hashtable to an `AppsScriptVariables.json` file in the `$OrchestrationPath` folder (`$AppsPath\Orchestration`). You can also manually create your own `AppsScriptVariables.json `file and place it in the `$AppsPath\Orchestration` folder.
+
+In the VM, the `Orchestrator.ps1` file will call `Invoke-AppsScript.ps1` if `AppsScriptVariables.json` exists. `Invoke-AppsScript.ps1` must be modified to handle your variables.
+
+`Invoke-AppsScript.ps1` has the following commented example of how to modify the file:
+
+```
+# Example of how to use the AppsScriptVariables hashtable to control script execution
+
+# Note: The UI saves the values as strings, so if you type true for a value, it'll save to the config file as a string, not boolean
+
+# Example: Check if a variable named 'foo' is set to string 'bar' and run a script accordingly
+# if ($AppsScriptVariables['foo'] -eq 'bar') {
+#     Write-Host "Foo would have installed"
+# }
+# else {
+#     Write-Host "Foo would not have installed"
+# }
+
+# Example: Check if a variable named 'Teams' is set to string 'true' and run a script accordingly
+# if ($AppsScriptVariables['Teams'] -eq 'true') {
+#     Write-Host "Teams would have been installed"
+# }
+# else {
+#     Write-Host "Teams would not have been installed"
+# }
+```
+
+## Why use Apps Script Variables?
+
+This allows for you to create a dynamic task sequence via a PowerShell script with simple if statements to run apps, commands, etc. This is all driven by your `FFUConfig.json` file. For example, the following `FFUConfig.json` file contains an AppsScriptVariables hashtable of foo and vmwaretools like the screenshot above. If you build servers that require vmware tools, you may set the value to true. However there may be situations where you don't need vmwaretools installed. If that's the case, you set vmwaretools to false. This allows for your `Invoke-AppsScript.ps1` file to stay the same and all you have to do is adjust the variables.
+
+```
+{
+  "AdditionalFFUFiles": [],
+  "AllowExternalHardDiskMedia": false,
+  "AllowVHDXCaching": false,
+  "AppListPath": "C:\\FFUDevelopment\\Apps\\AppList.json",
+  "AppsPath": "C:\\FFUDevelopment\\Apps",
+  "AppsScriptVariables": {
+    "foo": "bar",
+    "vmwaretools": "true"
+  },
+  "BuildUSBDrive": false,
+  "CleanupAppsISO": true,
+  "CleanupCaptureISO": true,
+  "CleanupDeployISO": true,
+  "CleanupDrivers": false,
+  "CompactOS": true,
+  "CompressDownloadedDriversToWim": false,
+  "CopyAdditionalFFUFiles": false,
+  "CopyAutopilot": false,
+  "CopyDrivers": false,
+  "CopyOfficeConfigXML": false,
+  "CopyPEDrivers": false,
+  "CopyPPKG": false,
+  "CopyUnattend": false,
+  "CreateCaptureMedia": true,
+  "CreateDeploymentMedia": true,
+  "CustomFFUNameTemplate": "{WindowsRelease}_{WindowsVersion}_{SKU}_{yyyy}-{MM}-{dd}_{HH}{mm}",
+  "Disksize": 53687091200,
+  "DownloadDrivers": false,
+  "DriversFolder": "C:\\FFUDevelopment\\Drivers",
+  "DriversJsonPath": "C:\\FFUDevelopment\\Drivers\\Drivers.json",
+  "FFUCaptureLocation": "C:\\FFUDevelopment\\FFU",
+  "FFUDevelopmentPath": "C:\\FFUDevelopment",
+  "FFUPrefix": "_FFU",
+  "InjectUnattend": false,
+  "InstallApps": true,
+  "InstallDrivers": false,
+  "InstallOffice": false,
+  "InstallWingetApps": false,
+  "ISOPath": "",
+  "LogicalSectorSizeBytes": 512,
+  "MaxUSBDrives": 5,
+  "MediaType": "Consumer",
+  "Memory": 4294967296,
+  "OfficeConfigXMLFile": "",
+  "OfficePath": "C:\\FFUDevelopment\\Apps\\Office",
+  "Optimize": true,
+  "OptionalFeatures": "",
+  "OrchestrationPath": "C:\\FFUDevelopment\\Apps\\Orchestration",
+  "PEDriversFolder": "C:\\FFUDevelopment\\PEDrivers",
+  "Processors": 4,
+  "ProductKey": "",
+  "PromptExternalHardDiskMedia": true,
+  "RemoveApps": false,
+  "RemoveFFU": false,
+  "RemoveUpdates": false,
+  "ShareName": "FFUCaptureShare",
+  "Threads": 5,
+  "UpdateADK": true,
+  "UpdateEdge": true,
+  "UpdateLatestCU": true,
+  "UpdateLatestDefender": true,
+  "UpdateLatestMicrocode": false,
+  "UpdateLatestMSRT": true,
+  "UpdateLatestNet": true,
+  "UpdateOneDrive": true,
+  "UpdatePreviewCU": false,
+  "USBDriveList": {},
+  "UseDriversAsPEDrivers": false,
+  "UserAppListPath": "C:\\FFUDevelopment\\Apps\\UserAppList.json",
+  "Username": "ffu_user",
+  "Verbose": false,
+  "VMHostIPAddress": "192.168.1.169",
+  "VMLocation": "C:\\FFUDevelopment\\VM",
+  "VMSwitchName": "External",
+  "WindowsArch": "x64",
+  "WindowsLang": "en-us",
+  "WindowsRelease": 11,
+  "WindowsSKU": "Pro",
+  "WindowsVersion": "25H2"
+}
+
+```
+
+Example command line to run with vmwaretools set to false and foo set to foo. This will create the `AppsScriptVariables.json` file in the Orchestration folder with the updated values of `foo=foo` and `vmwaretools=false` without the need to modify the config file.
+
+`.\BuildFFUVM.ps1 -configFile 'C:\FFUDevelopment\config\FFUConfig.json' -appsScriptVariables @{foo='foo'; vmwaretools='false'}`
+
+
+
+{% include page_nav.html %}

docs/assets/js/external-links.js

@@ -0,0 +1,91 @@
+(function () {
+    'use strict';
+
+    function HasToken(tokens, token) {
+        for (var i = 0; i < tokens.length; i++) {
+            if (tokens[i] === token) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    function AddRelToken(anchor, token) {
+        var rel = (anchor.getAttribute('rel') || '').trim();
+        var tokens = rel ? rel.split(/\s+/) : [];
+
+        if (!HasToken(tokens, token)) {
+            tokens.push(token);
+        }
+
+        anchor.setAttribute('rel', tokens.join(' ').trim());
+    }
+
+    function IsExternalHttpLink(url) {
+        if (!url) {
+            return false;
+        }
+
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+            return false;
+        }
+
+        return url.origin !== window.location.origin;
+    }
+
+    function InitExternalLinksNewTab() {
+        var mainContent = document.querySelector('.main-content');
+        if (!mainContent) {
+            return;
+        }
+
+        var anchors = mainContent.querySelectorAll('a[href]');
+        for (var i = 0; i < anchors.length; i++) {
+            var anchor = anchors[i];
+            var href = (anchor.getAttribute('href') || '').trim();
+
+            if (!href) {
+                continue;
+            }
+
+            if (href.charAt(0) === '#') {
+                continue;
+            }
+
+            if (href.indexOf('mailto:') === 0 || href.indexOf('tel:') === 0 || href.indexOf('javascript:') === 0) {
+                continue;
+            }
+
+            var url = null;
+            try {
+                url = new URL(href, window.location.href);
+            } catch (e) {
+                continue;
+            }
+
+            if (!IsExternalHttpLink(url)) {
+                continue;
+            }
+
+            var target = (anchor.getAttribute('target') || '').trim();
+
+            if (!target) {
+                anchor.setAttribute('target', '_blank');
+                target = '_blank';
+            }
+
+            if (target === '_blank') {
+                AddRelToken(anchor, 'noopener');
+                AddRelToken(anchor, 'noreferrer');
+            }
+        }
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', InitExternalLinksNewTab);
+        return;
+    }
+
+    InitExternalLinksNewTab();
+})();

docs/assets/js/image-zoom.js

@@ -0,0 +1,22 @@
+(function () {
+    'use strict';
+
+    function InitImageZoom() {
+        if (window.mediumZoom === undefined) {
+            return;
+        }
+
+        window.mediumZoom('.main-content img:not(.no-zoom):not([src$=".svg"])', {
+            margin: 24,
+            background: 'rgba(0,0,0,0.80)',
+            scrollOffset: 0
+        });
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', InitImageZoom);
+        return;
+    }
+
+    InitImageZoom();
+})();

docs/assets/js/page-toc.js

@@ -0,0 +1,403 @@
+(function () {
+    'use strict';
+
+    var scrollSpyDispose = null;
+    var resizeReinitTimerId = null;
+    var inlineMaxVisibleItems = 4;
+
+    function IsRightTocEnabled() {
+        var meta = document.querySelector('meta[name="ffu-right-toc"]');
+        if (meta && meta.content && meta.content.toLowerCase() === 'false') {
+            return false;
+        }
+
+        return true;
+    }
+
+    function IsDesktopViewport() {
+        try {
+            return window.matchMedia && window.matchMedia('(min-width: 66.5rem)').matches;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    function RemoveExistingToc() {
+        if (scrollSpyDispose) {
+            scrollSpyDispose();
+            scrollSpyDispose = null;
+        }
+
+        var existingTocs = document.querySelectorAll('.page-toc');
+        for (var i = 0; i < existingTocs.length; i++) {
+            existingTocs[i].remove();
+        }
+
+        var wrap = document.querySelector('.main-content-wrap');
+        if (wrap) {
+            wrap.classList.remove('has-page-toc');
+        }
+    }
+
+    function InsertInlineToc(main, toc) {
+        if (!main || !toc) {
+            return;
+        }
+
+        var title = main.querySelector('h1');
+        if (title && title.parentNode === main) {
+            if (title.nextSibling) {
+                main.insertBefore(toc, title.nextSibling);
+                return;
+            }
+
+            main.appendChild(toc);
+            return;
+        }
+
+        if (main.firstChild) {
+            main.insertBefore(toc, main.firstChild);
+            return;
+        }
+
+        main.appendChild(toc);
+    }
+
+    function GetHeadings(container) {
+        var headings = container.querySelectorAll('h2, h3');
+        var results = [];
+
+        for (var i = 0; i < headings.length; i++) {
+            var heading = headings[i];
+
+            if (heading.classList.contains('no_toc')) {
+                continue;
+            }
+
+            var id = heading.getAttribute('id');
+            if (!id) {
+                continue;
+            }
+
+            var text = (heading.textContent || '').trim();
+            if (!text) {
+                continue;
+            }
+
+            results.push({
+                level: heading.tagName.toLowerCase(),
+                id: id,
+                text: text
+            });
+        }
+
+        return results;
+    }
+
+    function BuildToc(headings, options) {
+        var variant = (options && options.variant) ? options.variant : 'right';
+        var maxVisible = (options && options.maxVisible) ? options.maxVisible : 0;
+        var isInline = 'inline' === variant;
+
+        var nav = document.createElement('nav');
+        nav.className = 'page-toc' + (isInline ? ' page-toc--inline' : '');
+        nav.setAttribute('aria-label', 'On this page');
+
+        var title = document.createElement('div');
+        title.className = 'page-toc__title';
+        title.textContent = 'In this article';
+        nav.appendChild(title);
+
+        var list = document.createElement('ul');
+        list.className = 'page-toc__list';
+        list.id = 'page-toc-list';
+
+        for (var i = 0; i < headings.length; i++) {
+            var item = headings[i];
+
+            var li = document.createElement('li');
+            li.className = 'page-toc__item page-toc__item--' + item.level;
+
+            var a = document.createElement('a');
+            a.className = 'page-toc__link';
+            a.href = '#' + item.id;
+            a.textContent = item.text;
+
+            li.appendChild(a);
+            list.appendChild(li);
+
+            if (isInline && maxVisible > 0 && i >= maxVisible) {
+                li.classList.add('is-hidden');
+            }
+        }
+
+        nav.appendChild(list);
+
+        if (isInline && maxVisible > 0 && headings.length > maxVisible) {
+            var hiddenCount = headings.length - maxVisible;
+            var isExpanded = false;
+
+            var toggle = document.createElement('button');
+            toggle.type = 'button';
+            toggle.className = 'page-toc__toggle';
+            toggle.setAttribute('aria-controls', list.id);
+            toggle.setAttribute('aria-expanded', 'false');
+
+            function SetToggleText() {
+                if (isExpanded) {
+                    toggle.textContent = 'Show less';
+                } else {
+                    toggle.textContent = 'Show ' + hiddenCount + ' more';
+                }
+            }
+
+            function SetHiddenState() {
+                var items = list.querySelectorAll('.page-toc__item');
+                for (var j = 0; j < items.length; j++) {
+                    if (j >= maxVisible) {
+                        if (isExpanded) {
+                            items[j].classList.remove('is-hidden');
+                        } else {
+                            items[j].classList.add('is-hidden');
+                        }
+                    }
+                }
+
+                toggle.setAttribute('aria-expanded', isExpanded ? 'true' : 'false');
+                SetToggleText();
+            }
+
+            toggle.addEventListener('click', function () {
+                isExpanded = !isExpanded;
+                SetHiddenState();
+            });
+
+            SetHiddenState();
+            nav.appendChild(toggle);
+        }
+
+        return nav;
+    }
+
+    function SetActiveTocLink(toc, activeId, keepVisibleInPanel) {
+        if (!toc) {
+            return;
+        }
+
+        var links = toc.querySelectorAll('.page-toc__link');
+        for (var i = 0; i < links.length; i++) {
+            var link = links[i];
+            var href = link.getAttribute('href') || '';
+            var isActive = ('#' + activeId) === href;
+
+            if (isActive) {
+                link.classList.add('is-active');
+
+                if (keepVisibleInPanel) {
+                    /* Keep the active item visible inside the TOC panel (desktop/right TOC only) */
+                    try {
+                        link.scrollIntoView({ block: 'nearest' });
+                    } catch (e) {
+                        link.scrollIntoView();
+                    }
+                }
+            } else {
+                link.classList.remove('is-active');
+            }
+        }
+    }
+
+    function SetupScrollSpy(main, toc, headings) {
+        if (!main || !toc || !headings || headings.length < 1) {
+            return null;
+        }
+
+        /* Scrollspy is desktop-only */
+        if (!IsDesktopViewport()) {
+            return null;
+        }
+
+        var headingElements = [];
+        for (var i = 0; i < headings.length; i++) {
+            var el = document.getElementById(headings[i].id);
+            if (el) {
+                headingElements.push(el);
+            }
+        }
+
+        if (headingElements.length < 1) {
+            return null;
+        }
+
+        var activeId = null;
+        var ticking = false;
+        var lockActiveUntilMs = 0;
+
+        function IsNearBottomOfPage() {
+            var thresholdPx = 24;
+            var scrollY = window.scrollY || window.pageYOffset || 0;
+            var viewportBottom = scrollY + window.innerHeight;
+            var pageHeight = Math.max(document.documentElement.scrollHeight, document.body.scrollHeight);
+
+            return viewportBottom >= (pageHeight - thresholdPx);
+        }
+
+        function GetCurrentHeadingId() {
+            /* If we're at the bottom, force the last heading active */
+            if (IsNearBottomOfPage()) {
+                return headingElements[headingElements.length - 1].getAttribute('id');
+            }
+
+            /* Choose the heading closest to the top "activation line" */
+            var activationLine = 16;
+            var current = null;
+
+            for (var i = 0; i < headingElements.length; i++) {
+                var rectTop = headingElements[i].getBoundingClientRect().top;
+
+                if (rectTop <= activationLine) {
+                    current = headingElements[i];
+                    continue;
+                }
+
+                if (null === current) {
+                    current = headingElements[i];
+                }
+
+                break;
+            }
+
+            if (null === current) {
+                current = headingElements[0];
+            }
+
+            return current.getAttribute('id');
+        }
+
+        function Update() {
+            ticking = false;
+
+            /* If the viewport becomes narrow after load, avoid scroll fighting */
+            if (!IsDesktopViewport()) {
+                return;
+            }
+
+            if (Date.now() < lockActiveUntilMs) {
+                return;
+            }
+
+            var currentId = GetCurrentHeadingId();
+            if (!currentId || currentId === activeId) {
+                return;
+            }
+
+            activeId = currentId;
+            SetActiveTocLink(toc, activeId, true);
+        }
+
+        function OnScrollOrResize() {
+            if (ticking) {
+                return;
+            }
+
+            ticking = true;
+            window.requestAnimationFrame(Update);
+        }
+
+        function OnTocClick(evt) {
+            var target = evt.target;
+            if (!target || !target.classList || !target.classList.contains('page-toc__link')) {
+                return;
+            }
+
+            var href = target.getAttribute('href') || '';
+            if (href.charAt(0) !== '#') {
+                return;
+            }
+
+            var id = href.substring(1);
+            if (!id) {
+                return;
+            }
+
+            /* Prevent scrollspy from immediately overriding the clicked section */
+            lockActiveUntilMs = Date.now() + 800;
+
+            activeId = id;
+            SetActiveTocLink(toc, activeId, true);
+        }
+
+        window.addEventListener('scroll', OnScrollOrResize, { passive: true });
+        window.addEventListener('resize', OnScrollOrResize);
+        toc.addEventListener('click', OnTocClick);
+
+        Update();
+
+        return function DisposeScrollSpy() {
+            window.removeEventListener('scroll', OnScrollOrResize);
+            window.removeEventListener('resize', OnScrollOrResize);
+            toc.removeEventListener('click', OnTocClick);
+        };
+    }
+
+    function InitRightToc() {
+        if (!IsRightTocEnabled()) {
+            RemoveExistingToc();
+            return;
+        }
+
+        var main = document.querySelector('.main-content main');
+        if (!main) {
+            return;
+        }
+
+        var headings = GetHeadings(main);
+        if (headings.length < 2) {
+            RemoveExistingToc();
+            return;
+        }
+
+        if (IsDesktopViewport()) {
+            RemoveExistingToc();
+
+            var wrap = document.querySelector('.main-content-wrap');
+            if (!wrap) {
+                return;
+            }
+
+            wrap.classList.add('has-page-toc');
+
+            var toc = BuildToc(headings, { variant: 'right' });
+            wrap.appendChild(toc);
+
+            scrollSpyDispose = SetupScrollSpy(main, toc, headings);
+            return;
+        }
+
+        /* Narrow viewports: place TOC at the top of the article (Learn-like) */
+        RemoveExistingToc();
+
+        var inlineToc = BuildToc(headings, { variant: 'inline', maxVisible: inlineMaxVisibleItems });
+        InsertInlineToc(main, inlineToc);
+    }
+
+    function OnViewportResize() {
+        if (null !== resizeReinitTimerId) {
+            window.clearTimeout(resizeReinitTimerId);
+        }
+
+        resizeReinitTimerId = window.setTimeout(InitRightToc, 150);
+    }
+
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', function () {
+            InitRightToc();
+            window.addEventListener('resize', OnViewportResize);
+        });
+
+        return;
+    }
+
+    InitRightToc();
+    window.addEventListener('resize', OnViewportResize);
+})();

docs/build.md

@@ -0,0 +1,822 @@
+---
+title: Build
+nav_order: 10
+prev_url: /drivers.html
+prev_label: Drivers
+next_url: /monitor.html
+next_label: Monitor
+parent: UI Overview
+---
+# Build
+
+![FFU Builder Build tab](image/build/1764362222174.png "FFU Builder Build tab")
+
+The Build tab is where the magic happens
+
+## FFU Development Path
+
+The FFU Development path (`$FFUDevelopmentPath`) is the root path of where most other paths are derived. The default is `$PSScriptRoot`, which is the location the script is currently running from and can be changed to another location from within the UI.
+
+If you want to download and test new releases, or want to create a new FFUDevelopment folder without modifying your existing one, you can always download the source files and put them in another location.
+
+The recommendation is to run from `C:\FFUDevelopment` and in most cases the path shouldn't need to be changed.
+
+## Custom FFU Name Template
+
+Controls the `-CustomFFUNameTemplate` parameter. This allows you to define a custom naming convention for the captured FFU file using placeholders that are replaced at build time.
+
+If left blank, the default FFU naming convention is used.
+
+### Available Placeholders
+
+| Placeholder          | Description            | Example                                                                        |
+| -------------------- | ---------------------- | ------------------------------------------------------------------------------ |
+| `{WindowsRelease}` | Windows release number | `10`, `11`, `2016`, `2019`, `2022`, `2025`                         |
+| `{WindowsVersion}` | Windows version        | `1607`, `1809`, `21h2`, `22h2`, `23h2`, `24h2`                     |
+| `{SKU}`            | Windows edition        | `Home`, `Pro`, `Enterprise`, `Education`, `Standard`, `Datacenter` |
+| `{BuildDate}`      | Month and year         | `Nov2025`                                                                    |
+| `{yyyy}`           | 4-digit year           | `2025`                                                                       |
+| `{MM}`             | 2-digit month          | `11` (for November)                                                          |
+| `{dd}`             | 2-digit day            | `28`                                                                         |
+| `{HH}`             | Hour in 24-hour format | `14` (for 2 PM)                                                              |
+| `{hh}`             | Hour in 12-hour format | `02` (for 2 PM)                                                              |
+| `{mm}`             | 2-digit minute         | `09`                                                                         |
+| `{tt}`             | AM/PM designator       | `AM` or `PM`                                                               |
+
+### Examples
+
+**Basic template with date and time:**
+
+```
+{WindowsRelease}_{WindowsVersion}_{SKU}_{yyyy}-{MM}-{dd}_{HH}{mm}
+```
+
+Result: `Win11_24h2_Pro_2025-11-28_1425.ffu`
+
+**Template with static text (e.g., indicating Office is installed):**
+
+```
+{WindowsRelease}_{WindowsVersion}_{SKU}_Office_{yyyy}-{MM}-{dd}_{HH}{mm}
+```
+
+Result: `Win11_24h2_Pro_Office_2025-11-28_1425.ffu`
+
+**Simple template with build date:**
+
+```
+{WindowsRelease}_{WindowsVersion}_{SKU}_{BuildDate}
+```
+
+Result: `Win11_24h2_Pro_Nov2025.ffu`
+
+{: .note-title}
+
+> Note
+>
+> The `.ffu` extension is automatically appended if not included in the template.
+
+## FFU Capture Location
+
+The FFU Capture Location sets the `-FFUCaptureLocation` parameter that determines where completed `.ffu` images are written. By default it points to `$FFUDevelopmentPath\FFU`, and the build script creates the folder automatically if it does not already exist.
+
+When apps are installed in a VM, the host converts this folder into a temporary SMB share using the **Share Name** and **Username** fields. The capture WinPE environment maps that share as drive `W:` and streams the captured image directly into this folder. When the build finishes, the share and local account are removed, but the FFU files remain unless a cleanup option deletes them.
+
+Choose a path on fast storage with plenty of free space—the directory must be local to the host running `BuildFFUVM.ps1`, and large captures can easily exceed 25–30 GB. This location also feeds other options such as **Copy Additional FFU Files**, **Build USB Drive**, and **Remove FFU**, so keeping all finished images here keeps those workflows simple.
+
+## Share Name
+
+The Share Name sets the `-ShareName` parameter that defines the name of the temporary SMB share created during the FFU capture process. The default is `FFUCaptureShare`.
+
+During the build, the host creates an SMB share that points to the **FFU Capture Location** and grants access to the temporary local user account defined in **Username**. The capture WinPE environment maps this share as drive `W:` using `net use` and streams the captured FFU image directly to it.
+
+When the build completes, the share is automatically removed along with the temporary user account, leaving only the captured FFU files behind in the FFU Capture Location.
+
+## Username
+
+The Username field sets the `-Username` parameter that `BuildFFUVM.ps1` uses when creating the temporary SMB share user. The value becomes a local standard user account that is granted Full Control on the **FFU Capture Location** share (default C:\FFUDevelopment\FFU) so the capture WinPE session can copy the FFU over `net use `. The default `ffu_user` account name works for most scenarios, but you can supply any other local account name that meets your organization's policies.
+
+When the build starts, the script ensures the account exists, rotates its password to a randomly generated GUID, and grants it access to the share. The Capture WinPE environment maps drive `W:` with those credentials, then writes the captured image directly into the FFU Capture Location.
+
+After the build finishes, the share is removed and the temporary account is deleted, leaving only the FFU files stored in the capture folder.
+
+## Threads
+
+Controls the `-Threads` parameter, which sets the number of parallel threads used for concurrent operations throughout FFU Builder. The default value is **5**.
+
+### Operations Affected by Threads
+
+The Threads value applies to the following parallel operations:
+
+| Operation                              | Description                                                                                                      |
+| -------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| **Winget Application Downloads** | When downloading multiple Winget applications, each application download runs as a parallel task                 |
+| **BYO Application Copy**         | When copying multiple Bring Your Own (BYO) applications to the Apps folder, each copy operation runs in parallel |
+| **Driver Downloads**             | When downloading drivers for multiple device models, each driver download and extraction runs as a parallel task |
+
+### Recommended Values
+
+| Threads        | Use Case                                                                  |
+| -------------- | ------------------------------------------------------------------------- |
+| **1**    | Minimal system impact; useful for troubleshooting or low-resource systems |
+| **5**    | Default; balanced performance for most systems                            |
+| **8-10** | Higher concurrency for systems with fast storage and network connections  |
+
+{: .note-title}
+
+> Note
+>
+> Setting a higher thread count may improve download times but will increase resource utilization. If you experience stability issues or resource constraints, try reducing the thread count.
+
+### Validation
+
+The UI validates that the Threads value is a valid integer greater than or equal to 1. If an invalid value is entered, it automatically resets to **1**.
+
+## BITS Priority
+
+Controls the `-BitsPriority` parameter, which determines the priority level for Background Intelligent Transfer Service (BITS) downloads. The default value is **Normal**.
+
+If you want faster downloads, change the priority to Foreground. Normal priority will significantly slow down downloads since BITS treats non-Foreground downloads as synchronous and queues each download. This means multiple driver or winget application downloads will go much slower than using Foreground. Normal is default as per Microsoft best practice guidance for using BITS.
+
+## Build USB Drive
+
+The following sub-options control how the USB drive is created
+
+### Allow External Hard Disk Media
+
+Controls the `-AllowExternalHardDiskMedia` parameter. When checked, allows the use of drives identified as "External hard disk media" via the WMI class `Win32_DiskDrive`. The default is **unchecked**.
+
+Most USB thumb drives are identified by Windows as "Removable Media" and work with the default settings. However, faster USB drives—such as portable SSDs or high-speed USB 3.x drives—may be identified as "External hard disk media" instead. If you want to use these faster drives for imaging, enable this option.
+
+{: .warning-title}
+
+> Warning
+>
+> Enabling this option may expose external hard drives attached to your machine to the USB imaging process. To prevent accidental data loss, use the **Prompt for External Hard Disk Media** option (enabled by default when this option is checked) to confirm which drive to use before formatting.
+
+### Prompt for External Hard Disk Media
+
+Controls the `-PromptExternalHardDiskMedia` parameter. When checked, prompts for user confirmation before using any drive identified as "External hard disk media". The default is **checked** when **Allow External Hard Disk Media** is enabled.
+
+This option is only available when **Allow External Hard Disk Media** is checked.
+
+When enabled, the build process will:
+
+1. Display a table listing all detected external hard disk media drives, including drive name, serial number, partition style, and status.
+2. Prompt you to select which drive to use for imaging.
+3. Only create a USB drive on the selected drive.
+
+When disabled, the script will not prompt and can use multiple external hard disk drives simultaneously, similar to how removable USB drives function. This is useful for automated or batch imaging scenarios but increases the risk of accidental data loss.
+
+{: .note-title}
+
+> Note
+>
+> If you do not want to be prompted each time, you can disable this option after verifying that only your intended imaging drives are connected.
+
+### Select Specific USB Drives
+
+When checked, enables manual selection of specific USB drives for imaging. The default is **unchecked**.
+
+This option is only available when **Build USB Drive** is checked.
+
+When enabled, a **Check USB drives** button and a list view appear. Click **Check USB drives** to scan for connected USB drives. The list displays all detected drives with the following information:
+
+| Column              | Description                                           |
+| ------------------- | ----------------------------------------------------- |
+| **Select**    | Checkbox to include or exclude the drive from imaging |
+| **Model**     | The model name of the USB drive                       |
+| **Unique ID** | A unique identifier for the drive                     |
+| **Size (GB)** | The total capacity of the drive in gigabytes          |
+
+Select one or more drives by checking the checkbox in the **Select** column. Only selected drives will be formatted and used for imaging when the build completes.
+
+Use the **Select All** checkbox in the column header to quickly select or deselect all drives.
+
+{: .note-title}
+
+> Note
+>
+> If **Select Specific USB Drives** is unchecked, the build process will automatically use all discovered USB drives.
+
+### Copy Autopilot Profile
+
+Controls the `-CopyAutopilot` parameter. When checked, copies the contents of the `.\FFUDevelopment\Autopilot` folder to the `Autopilot` folder on the Deployment partition of the USB drive. The default is **unchecked**.
+
+This option is only available when **Build USB Drive** is checked.
+
+This leverages the Autopilot for existing devices json file. It's not recommended to use this method any longer as devices enrolled via this method are enrolled as personal instead of corporate.
+
+### Copy Unattend.xml
+
+Controls the `-CopyUnattend` parameter. When checked, copies the architecture-appropriate unattend XML file from `.\FFUDevelopment\Unattend` to an `Unattend` folder on the Deployment partition of the USB drive. The default is **unchecked**.
+
+This option is only available when **Build USB Drive** is checked.
+
+When enabled, the build process copies:
+
+- **unattend_x64.xml** (for x64 builds) or **unattend_arm64.xml** (for arm64 builds) → renamed to **Unattend.xml** on the USB drive
+- **prefixes.txt** (if present) → copied alongside the unattend file
+
+During deployment, `ApplyFFU.ps1` detects the `Unattend` folder and uses these files to customize the device name and apply other Windows settings during OOBE.
+
+#### Device Naming
+
+Device naming can be done from PE. The way this works is by leveraging an unattend.xml file to either take input from the user at imaging time or read a list of prefix values and append the serial number of the device. There are some major benefits to doing this:
+
+1. Total deployment time is reduced if naming is set at FFU deployment time since there is no additional reboot done during OOBE.
+2. Reduces the need for multiple provisioning packages or autopilot profiles. This means you can use a single PPKG or autopilot profile.
+
+#### Prompt for Device Name
+
+If you want to be prompted for the device name, simply check **Copy Unattend.xml.** This tells the build script to copy the appropriate architecture unattend_arch.xml file from the `C:\FFUDevelopment\Unattend` folder to the `.\unattend` folder on the deploy partition of the USB drive.
+
+#### Device Naming with prefixes.txt
+
+If a `prefixes.txt` file exists in the `Unattend` folder and there are multiple prefixes in the file, the deployment script prompts the technician to select a prefix from the file. The prefix is combined with the device's serial number to create the computer name. If there is a single prefix, the technician is not prompted and the script will automatically select that prefix.
+
+For example, with a prefix of `CORP-` and a serial number of `ABC123`, the resulting computer name would be `CORP-ABC123` (truncated to 15 characters if necessary).
+
+Sample `prefixes.txt` content:
+
+```plaintext
+CORP-
+STORE-
+KIOSK-
+```
+
+{: .warning-title}
+
+> Warning
+>
+> If using a provisioning package or autopilot json file, DO NOT specify a name in either of these. They will overwrite the name you have specified in the unattend.xml.
+
+#### Creating Your Unattend Files
+
+The `.\FFUDevelopment\Unattend` folder includes sample files you can customize:
+
+| File                             | Description                                |
+| -------------------------------- | ------------------------------------------ |
+| **SampleUnattend_x64.xml** | Example unattend file for x64 systems      |
+| **unattend_x64.xml**       | Active unattend file used for x64 builds   |
+| **unattend_arm64.xml**     | Active unattend file used for arm64 builds |
+| **SamplePrefixes.txt**     | Example prefixes file for device naming    |
+
+Copy and customize the sample files to create your own `unattend_x64.xml`, `unattend_arm64.xml`, and `prefixes.txt` files.
+
+{: .note-title}
+
+> Note
+>
+> The unattend file must contain a `<ComputerName>` element in the `Microsoft-Windows-Shell-Setup` component for device naming to work. See the sample files for the correct structure.
+
+### Copy Provisioning Package
+
+Controls the `-CopyPPKG` parameter. When checked, copies the contents of the `.\FFUDevelopment\PPKG` folder to the `PPKG` folder on the Deployment partition of the USB drive. The default is **unchecked**.
+
+This option is only available when **Build USB Drive** is checked.
+
+#### How It Works
+
+1. **During Build**: The build process copies all `.ppkg` files from `.\FFUDevelopment\PPKG` to the USB drive.
+2. **During Deployment**: When `ApplyFFU.ps1` runs, it detects the `PPKG` folder and the provisioning packages within it.
+   - If **multiple** `.ppkg` files are found, the technician is prompted to select which package to apply.
+   - If **one** `.ppkg` file is found, it is automatically selected.
+3. **Application**: The selected provisioning package is copied to the root of the USB drive, where Windows picks it up during OOBE and applies the settings.
+
+### Copy Additional FFU Files
+
+Controls the `-CopyAdditionalFFUFiles` parameter. When checked, allows you to select existing FFU files from the FFU Capture Location to copy to the USB drive alongside the newly built FFU. The default is **unchecked**.
+
+This option is only available when **Build USB Drive** is checked.
+
+#### How It Works
+
+When enabled, an **Additional FFU Files** panel appears below the checkbox with the following controls:
+
+| Control                 | Description                                                                                     |
+| ----------------------- | ----------------------------------------------------------------------------------------------- |
+| **Refresh**       | Scans the FFU Capture Location folder for existing `.ffu` files and populates the list        |
+| **FFU Name**      | The filename of the FFU file                                                                    |
+| **Last Modified** | The date and time the FFU file was last modified, useful for identifying the most recent builds |
+
+The list displays all `.ffu` files found in the FFU Capture Location (default `.\FFUDevelopment\FFU`). Click on individual rows to select which FFU files you want to include on the USB drive. Selected files are highlighted in the list.
+
+#### Use Cases
+
+- **Multiple device configurations**: Copy different FFU files for different windows/application configurations (e.g., different versions of windows, different application stacks) to a single USB drive, allowing technicians to choose during deployment.
+- **Previous builds**: Include a known-good FFU from a previous build alongside the new build as a fallback option.
+- **Multi-architecture imaging**: Include both x64 and arm64 FFU files on the same USB drive for mixed-architecture environments.
+
+#### Command Line Usage
+
+When running `BuildFFUVM.ps1` from the command line with `-CopyAdditionalFFUFiles $true` and no `-AdditionalFFUFiles` parameter specified, the script displays an interactive prompt listing all available FFU files in the capture folder. You can:
+
+- Enter numbers separated by commas (e.g., `1,3,5`) to select specific files
+- Enter `A` to select all available files
+- Press **Enter** to skip and not include any additional files
+
+Example command line usage with pre-selected files:
+
+```powershell
+.\BuildFFUVM.ps1 -configFile .\config\FFUConfig.json -CopyAdditionalFFUFiles $true -AdditionalFFUFiles @("C:\FFUDevelopment\FFU\Win11_24h2_Pro_Nov2025.ffu", "C:\FFUDevelopment\FFU\Win11_24h2_Enterprise_Nov2025.ffu")
+```
+
+{: .note-title}
+
+> Note
+>
+> The newly captured FFU from the current build is always copied to the USB drive. Additional FFU files selected here are copied in addition to the new FFU.
+
+### Max USB Drives
+
+Controls the `-MaxUSBDrives` parameter, which sets the maximum number of USB drives to build in parallel. The default value is **5**.
+
+This option is only available when **Build USB Drive** is checked.
+
+When building USB drives, the script processes multiple drives concurrently to speed up imaging. This setting controls how many drives are formatted and copied to simultaneously.
+
+## Compact OS
+
+Controls the `-CompactOS` parameter. When checked, the Windows image is applied using compressed files. The default is **checked**.
+
+### How It Works
+
+When enabled, the build script uses the `-Compact` switch with `Expand-WindowsImage` when applying the Windows image to the OS partition. This compresses Windows system files using Compact OS compression, which reduces the disk footprint of the operating system. On an x64 image, space savings is ~3.5-4GB.
+
+### Benefits
+
+| Benefit                         | Description                                                                                          |
+| ------------------------------- | ---------------------------------------------------------------------------------------------------- |
+| **Reduced Disk Space**    | Windows files are stored in a compressed state, saving several gigabytes of storage                  |
+| **Smaller FFU Size**      | The captured FFU file is smaller because the OS partition contains compressed files                  |
+| **Faster Deployment**     | Smaller FFU files transfer more quickly to USB drives and deploy faster to target devices            |
+| **No Performance Impact** | Modern CPUs decompress files faster than they can be read from storage, so performance is maintained |
+
+### When to Disable
+
+You may want to disable Compact OS in the following scenarios:
+
+- **Windows Server builds**: The script automatically disables Compact OS for Windows Server operating systems because the Windows Overlay Filter (wof.sys) is not included in Server SKUs
+- **Troubleshooting**: If you experience issues with specific applications that are incompatible with compressed files
+- **Maximum performance requirements**: In rare cases where every CPU cycle matters
+
+{: .note-title}
+
+> Note
+>
+> Compact OS is automatically disabled when building Windows Server images, regardless of this setting. The script detects Server operating systems and applies the Windows image without compression.
+
+## Update ADK
+
+Controls the `-UpdateADK` parameter. When checked, the script checks for and installs or updates to the latest Windows ADK and WinPE add-on before starting the build. The default is **checked**.
+
+### How It Works
+
+When enabled, the build process performs the following checks before starting:
+
+1. **Version Check**: Queries the [Microsoft ADK installation page](https://learn.microsoft.com/en-us/windows-hardware/get-started/adk-install) to determine the latest available ADK version
+2. **Compare Versions**: Compares the installed ADK and WinPE add-on versions (if present) against the latest available version
+3. **Update if Needed**: If an older version is detected:
+   - Uninstalls the existing Windows ADK
+   - Uninstalls the existing WinPE add-on
+   - Downloads and installs the latest Windows ADK with Deployment Tools feature
+   - Downloads and installs the latest WinPE add-on
+
+### Features Installed
+
+When installing or updating the ADK, the following features are included:
+
+| Component                          | Feature ID                                     | Description                                                     |
+| ---------------------------------- | ---------------------------------------------- | --------------------------------------------------------------- |
+| **Windows Deployment Tools** | `OptionId.DeploymentTools`                   | Includes DISM, Oscdimg, and other deployment-related tools      |
+| **WinPE Environment**        | `OptionId.WindowsPreinstallationEnvironment` | Windows Preinstallation Environment used for capture and deploy |
+
+### Installation Location
+
+The ADK is installed to the default location: `C:\Program Files (x86)\Windows Kits\10`
+
+### When to Disable
+
+You may want to disable Update ADK in the following scenarios:
+
+- **Offline or air-gapped environments**: When internet access is not available to download the latest ADK
+- **Controlled ADK versions**: When you need to maintain a specific ADK version for compatibility or compliance reasons
+- **Faster builds**: When you have already verified you are running the latest ADK version and want to skip the version check
+
+{: .warning-title}
+
+> Warning
+>
+> If Update ADK is disabled and the Windows ADK or WinPE add-on is not installed, the build will fail. Ensure you have manually installed the required components before disabling this option.
+
+### Manual ADK Installation
+
+If you prefer to manually install the ADK, visit:
+
+[Download and install the Windows ADK](https://learn.microsoft.com/en-us/windows-hardware/get-started/adk-install)
+
+You must install both:
+
+- Windows Assessment and Deployment Kit (with Deployment Tools feature)
+- Windows PE add-on for the Windows ADK
+
+## Optimize
+
+Controls the `-Optimize` parameter. When enabled, FFU Builder runs the Windows ADK version of DISM to optimize the captured `.ffu` file:
+
+- `DISM /Optimize-FFU /ImageFile:<path-to-ffu>`
+
+This post-processing step typically takes a few minutes and is intended to make FFU images faster to deploy and easier to deploy to differently-sized disks (by allowing the Windows partition to expand or shrink during apply).
+
+**Default:** Enabled (`-Optimize $true`)
+
+### When to Disable
+
+You may want to disable Optimize (`-Optimize $false`) if you are troubleshooting, or if you want to skip the extra post-processing time.
+
+{: .warning-title}
+
+> Warning
+>
+> If you plan to deploy the same FFU to devices with different storage sizes (especially smaller disks), keep `-Optimize` enabled. Non-optimized FFUs are more likely to require additional partition management during deployment.
+
+{: .note-title}
+
+> Note
+>
+> FFU Builder also performs a separate “optimize VHDX before capture” step. That VHDX optimization is independent of `-Optimize`, so you may still see “Optimizing VHDX before capture…” even when `-Optimize` is disabled.
+
+## Allow VHDX Caching
+
+Controls the `-AllowVHDXCaching` parameter. When enabled, FFU Builder caches the base VHDX it creates in `$FFUDevelopmentPath\VHDXCache` and writes a matching `*_config.json` file alongside it. On later builds, if a cached VHDX exists that matches your selected Windows settings and update set, the script reuses it to avoid re-applying the base image and integrating updates again.
+
+**Default:** Disabled (`-AllowVHDXCaching $false`)
+
+### Cache Matching
+
+A cached VHDX is reused only when the cache metadata matches your current build inputs, including:
+
+- Windows release, version, and SKU
+- Logical sector size (512 vs 4096)
+- Optional features selection
+- The exact set of update payload file names downloaded for that run (SSU/CU/.NET/etc.)
+
+### Disk Usage and Cleanup
+
+VHDX caching trades disk space for speed. The `VHDXCache` folder can grow over time as you build different combinations. Periodically check the folder and remove old cached vhdx and config json files as necessary.
+
+{: .note-title}
+
+> Note
+>
+> To force a full rebuild, delete the contents of `$FFUDevelopmentPath\VHDXCache` (or disable **Allow VHDX Caching**) and run the build again.
+
+## Create Capture Media
+
+Controls the `-CreateCaptureMedia` parameter.
+
+When enabled, FFU Builder creates WinPE capture media that is used during VM-based builds (when apps are installed in the VM). FFU Builder attaches this media to the VM and adjusts boot order so the VM can reboot into WinPE and automatically capture the FFU to your **FFU Capture Location**.
+
+The capture media uses the parameter values from `VMHostIPAddress`, `ShareName`, `UserName`, and `CustomFFUNameTemplate` and inserts them into `CaptureFFU.ps1` which is what is responsible for capturing the FFU from the guest VM to the Host.
+
+**Default:** Enabled (`-CreateCaptureMedia $true`)
+
+{: .note-title}
+
+> Note
+>
+> This option is only relevant when **Install Apps** is enabled. If **Install Apps** is enabled, the build forces `-CreateCaptureMedia` to `$true` because capture media is required to capture an FFU from the VM.
+
+{: .tip-title}
+
+> Tip
+>
+> If you just need to re-create media, you can use the `Create-PEMedia.ps1` script to regenerate the capture or deploy ISO using `Create-PEMedia.ps1 -Capture $true` or `CreatePEMedia.ps1 -Deploy $true`.
+
+## Create Deployment Media
+
+Controls the `-CreateDeploymentMedia` parameter.
+
+When enabled, FFU Builder creates WinPE deployment media that is used to deploy an FFU image to a physical device. This media contains the WinPE environment and deployment scripts needed to boot a target machine and apply the FFU image.
+
+The deployment media is saved as an ISO file at `$FFUDevelopmentPath\WinPE_FFU_Deploy_x64.iso` (or `WinPE_FFU_Deploy_arm64.iso` for ARM64 builds). This ISO can then be used with the **Build USB Drive** option to create bootable USB media for physical deployments.
+
+**Default:** Enabled (`-CreateDeploymentMedia $true`)
+
+{: .note-title}
+
+> Note
+>
+> If you only need to capture FFUs from VMs and do not plan to deploy to physical devices, you can disable this option to save time during the build process. However, most scenarios require deployment media for the final step of applying the FFU to target hardware.
+
+{: .tip-title}
+
+> Tip
+>
+> If you just need to re-create media, you can use the `Create-PEMedia.ps1` script to regenerate the capture or deploy ISO using `Create-PEMedia.ps1 -Capture $true` or `CreatePEMedia.ps1 -Deploy $true`.
+
+## Inject Unattend.xml
+
+Controls the `-InjectUnattend` parameter. When checked, copies the architecture-specific unattend XML file from `.\FFUDevelopment\unattend` into the Apps ISO so it's baked into the FFU during the VM build process. The default is **unchecked**.
+
+This option is only available when **Install Apps** is checked.
+
+### How It Works
+
+When enabled, the build process:
+
+1. Determines the correct unattend file based on the target architecture:
+   * **unattend_x64.xml** for x64 builds
+   * **unattend_arm64.xml** for arm64 builds
+2. Creates an `Unattend` folder inside `.\FFUDevelopment\Apps` if it doesn't exist
+3. Copies the architecture-specific unattend file to `.\FFUDevelopment\Apps\Unattend\Unattend.xml`
+4. Includes the unattend file in the Apps ISO, making it available to sysprep during the VM build
+
+The unattend file is then used by sysprep during the specialize phase and/or other OOBE phases when the FFU is deployed.
+
+### Creating Your Unattend Files
+
+Modify the architecture-specific unattend file in the `.\FFUDevelopment\unattend` folder:
+
+| File                         | Description                         |
+| ---------------------------- | ----------------------------------- |
+| **unattend_x64.xml**   | Unattend file used for x64 builds   |
+| **unattend_arm64.xml** | Unattend file used for arm64 builds |
+
+{: .warning-title}
+
+> Important
+>
+> Keep the file names with the architecture suffix (e.g., unattend_x64.xml). The script handles renaming the file to `Unattend.xml` when copying it to the Apps folder.
+
+### When to Use This Option
+
+This option is primarily intended for scenarios where:
+
+* You are **not using the USB drive** to deploy the FFU and use other deployment methods (e.g., network deployment, disk cloning, etc)
+* You want the unattend configuration **baked directly into the FFU** rather than applied at deployment time
+
+### Limitations
+
+| Limitation                        | Description                                                                                                                                              |
+| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **No prefixes.txt support** | Unlike the**Copy Unattend** option for USB drives, this method does not support `prefixes.txt` for dynamic device naming based on serial numbers |
+| **Fixed configuration**     | The unattend settings are baked into the FFU at build time and cannot be changed at deployment time                                                      |
+| **Requires VM to be built** | This option only works when**Install Apps** is `$true` because the unattend file is included in the Apps ISO                                     |
+
+{: .note-title}
+
+> Note
+>
+> Most users should continue using the **Copy Unattend** option via the USB drive, which provides more flexibility including support for `prefixes.txt` device naming. Use **Inject Unattend.xml** only when you won't be using the USB drive for deployment.
+
+{: .tip-title}
+
+> Tip
+>
+> If you're using this option, you can disable **Build Deploy ISO** to save time during the build process since the deployment ISO is not needed when you're not using the USB drive method.
+
+## Verbose
+
+Controls the `-Verbose` common parameter. When checked, enables detailed verbose output during the build process. The default is **unchecked**.
+
+In prior builds it was necessary to enable `-verbose` output to track in real-time the build process if you didn't have `cmtrace.exe` or some other log-monitoring tool. With the UI, you can now watch the build in real-time using the monitor tab. Enabling verbose shouldn't be necessary but is available for those who wish to use it.
+
+# Post-Build Cleanup
+
+## Cleanup Apps ISO
+
+Controls the `-CleanupAppsISO` parameter. When checked, the Apps ISO file is automatically deleted after the FFU has been successfully captured. The default is **checked**.
+
+During the build process, when apps are being installed, the script creates an `Apps.iso` file in the FFU Development Path (e.g., `.\FFUDevelopment\Apps.iso`). This ISO contains the contents of the `.\FFUDevelopment\Apps` folder—including application installers, Office deployment files, and orchestration scripts—and is mounted to the VM during the build to install applications.
+
+### When to Disable
+
+You may want to disable Cleanup Apps ISO in the following scenarios:
+
+* **Debugging app installations**: When troubleshooting application installation issues and you want to manually inspect the ISO contents
+* **Multiple builds with same apps**: If you're running consecutive builds with identical app configurations and want to reuse the existing ISO to save time (the script will recreate it if missing)
+* **Archival purposes**: When you need to retain a copy of the exact Apps ISO used for a specific FFU build
+
+{: .note-title}
+
+> Note
+>
+> The Apps ISO is only created when applications are configured for installation. If no apps are being installed in the FFU, this option has no effect. Keeping this option enabled helps conserve disk space by removing temporary build artifacts.
+
+## Cleanup Capture ISO
+
+Controls the `-CleanupCaptureISO` parameter. When checked, the WinPE capture ISO file is automatically deleted after the FFU has been successfully captured. The default is **checked**.
+
+It's recommended to keep this checked as each new build re-creates the local username account (e.g. `ffu_user`) and its password. If you were to retain the capture ISO from a previous build, it'd be using an old password and the capture would fail.
+
+## Cleanup Deploy ISO
+
+Controls the `-CleanupDeployISO` parameter. When checked, the WinPE deployment ISO file is automatically deleted after the FFU has been successfully captured. The default is **checked**.
+
+During the build process, when **Build Deploy ISO** is enabled, the script creates a `WinPE_FFU_Deploy.iso` file (e.g., `.\FFUDevelopment\WinPE_FFU_Deploy.iso`). This ISO contains a customized Windows PE environment used to deploy captured FFU images to target devices. The deployment ISO is typically copied to a bootable USB drive along with the FFU files for field deployment.
+
+### When to Disable
+
+You may want to disable Cleanup Deploy ISO in the following scenarios:
+
+* **Creating deployment media separately**: When you want to create USB deployment drives at a later time, see [USB Imaging Tool Creator](/FFU/usb_imaging_tool_creator.html) for a staged workflow using `USBImagingToolCreator.ps1` with a deploy ISO, `FFU`, and `Drivers` folder (local path or network share).
+* **Testing in Hyper-V**: When deploying FFU images to Hyper-V VMs for testing, you can attach the deploy ISO directly to a VM as a DVD drive
+
+## Cleanup Drivers
+
+Controls the `-CleanupDrivers` parameter. When checked, the contents of the Drivers folder are automatically deleted after the FFU has been successfully captured. The default is **unchecked**.
+
+During the build process, when drivers are configured for installation, the script downloads and extracts driver packages into manufacturer-specific subfolders within the Drivers folder (e.g., `.\FFUDevelopment\Drivers\HP`, `.\FFUDevelopment\Drivers\Dell`). These drivers are then injected into the FFU during the build.
+
+### When to Enable
+
+You may want to enable Cleanup Drivers in the following scenarios:
+
+* **Conserving disk space**: Driver packages can be large (several gigabytes per manufacturer), and removing them after a successful build frees up storage
+* **Ensuring fresh drivers**: When you want each build to download the latest available drivers rather than reusing previously downloaded versions
+* **Single-use builds**: When building an FFU for a one-time deployment and you don't need to retain the driver files
+
+### When to Disable
+
+You may want to keep Cleanup Drivers disabled in the following scenarios:
+
+* **Multiple builds with same drivers**: If you're running consecutive builds targeting the same hardware models, keeping drivers avoids re-downloading them each time
+* **Debugging driver issues**: When troubleshooting driver injection problems and you want to manually inspect the downloaded driver contents
+* **Offline builds**: When building in an environment with limited or no internet access, retaining drivers allows reuse across builds
+* **Bring Your Own Drivers:** When you download and bring your own set of drivers from another source and don't want FFU Builder to remove them
+
+{: .note-title}
+
+> Note
+>
+> Only the contents within the Drivers folder are removed—the folder itself is preserved. If no drivers were downloaded during the build, this option has no effect.
+
+## Remove FFU
+
+Controls the `-RemoveFFU` parameter. When checked, all FFU files in the FFU Capture Location are automatically deleted after the build completes successfully. The default is **unchecked**.
+
+During the build process, the captured FFU image is written to the FFU Capture Location (e.g., `.\FFUDevelopment\FFU`). This option removes all `.ffu` files from that folder after the build finishes, including any previously captured FFU files that may exist in the folder.
+
+### When to Enable
+
+You may want to enable Remove FFU in the following scenarios:
+
+* **USB-only workflow**: When you're using **Build USB Drive** to copy the FFU directly to a USB drive and don't need to retain the FFU file on the host machine
+* **Conserving disk space**: FFU files can be very large depending on what you're installing, and removing them after copying to USB frees up storage
+* **Automated build pipelines**: When running automated builds where the FFU is immediately transferred to another location (such as a network share or deployment server) and no longer needed locally
+
+### When to Disable
+
+You may want to keep Remove FFU disabled in the following scenarios:
+
+* **Archival purposes**: When you want to retain captured FFU images for future deployments or as a backup
+* **Multiple USB drives**: When you need to create additional USB deployment drives at a later time
+* **Testing and validation**: When you want to test the FFU in Hyper-V or other environments before deploying to physical hardware
+
+{: .warning-title}
+
+> Warning
+>
+> This option removes **all** FFU files in the FFU Capture Location folder, not just the FFU from the current build. If you have previously captured FFU files stored in this folder that you want to keep, do not enable this option or move those files to a different location before building.
+
+## Remove Apps Folder Content
+
+Controls the `-RemoveApps` parameter. When checked, application content in the Apps folder is automatically deleted after the FFU has been successfully captured. The default is **un****checked**.
+
+During the build process, application content accumulates in several subfolders within the Apps folder (e.g., `.\FFUDevelopment\Apps`):
+
+| Folder      | Contents                                                                                                                 |
+| ----------- | ------------------------------------------------------------------------------------------------------------------------ |
+| `Win32`   | Winget source applications and Bring Your Own Apps content copied using the**Copy Apps** button or manually copied |
+| `MSStore` | Microsoft Store applications downloaded via Winget                                                                       |
+| `Office`  | Microsoft 365 Apps installer files downloaded by the Office Deployment Tool                                              |
+
+Additionally, the `WinGetWin32Apps.json` orchestration file in `.\FFUDevelopment\Apps\Orchestration` is removed. This file is automatically regenerated at build time based on downloaded applications.
+
+When this option is enabled, the cleanup process removes:
+
+* The entire `Win32` folder and its contents
+* The entire `MSStore` folder and its contents
+* The Office download subfolder (`Office\Office`) and the `setup.exe` file within the `Office` folder
+
+### When to Enable
+
+You may want to keep Remove Apps Folder Content enabled in the following scenarios:
+
+* **Conserving disk space**: Downloaded application installers can consume significant storage, and removing them after a successful build frees up space
+* **Ensuring fresh downloads**: When you want each build to download the latest available application versions rather than reusing previously downloaded content
+* **Single-use builds**: When building an FFU for a one-time deployment and you don't need to retain the application files
+
+### When to Disable
+
+You may want to disable Remove Apps Folder Content in the following scenarios:
+
+* **Multiple builds with same apps**: If you're running consecutive builds with identical application configurations, keeping the downloaded content avoids re-downloading applications each time
+* **Debugging app installations**: When troubleshooting application installation issues and you want to manually inspect the downloaded content
+* **Offline builds**: When building in an environment with limited or no internet access, retaining downloaded applications allows reuse across builds
+* **Preserving Bring Your Own Apps**: When you've manually copied application content into the `Win32` folder and don't want FFU Builder to remove it
+
+{: .note-title}
+
+> Note
+>
+> Only the application content subfolders are removed—the `Apps` folder itself and configuration files such as `AppList.json` and `UserAppList.json` are preserved. If no applications were configured for the build, this option has no effect.
+
+## Remove Downloaded Update Files
+
+Controls the `-RemoveUpdates` parameter. When checked, downloaded Windows updates and application update payloads are automatically deleted after the FFU has been successfully captured. The default is **unchecked**.
+
+During the build process, update files are downloaded to specific locations within the `FFUDevelopment` folder:
+
+| Folder            | Contents                                                   |
+| ----------------- | ---------------------------------------------------------- |
+| `KB`            | Windows Cumulative Updates (CU) and .NET Framework updates |
+| `Apps\Defender` | Microsoft Defender definition updates                      |
+| `Apps\Edge`     | Microsoft Edge browser installer                           |
+| `Apps\MSRT`     | Malicious Software Removal Tool updates                    |
+| `Apps\OneDrive` | Microsoft OneDrive installer                               |
+
+When this option is enabled, the cleanup process removes the entire `KB` folder and the specific update subfolders within the `Apps` directory.
+
+### When to Enable
+
+You may want to keep Remove Downloaded Update Files enabled in the following scenarios:
+
+* **Conserving disk space**: Windows Cumulative Updates can be several gigabytes in size, and removing them after a successful build frees up significant storage
+* **Ensuring latest updates**: When you want each build to download the absolute latest available updates rather than potentially reusing older cached versions
+
+### When to Disable
+
+You may want to disable Remove Downloaded Update Files in the following scenarios:
+
+* **Multiple builds**: If you're running consecutive builds, keeping the downloaded updates avoids re-downloading large Cumulative Update files each time
+* **Offline builds**: When building in an environment with limited or no internet access, retaining downloaded updates allows reuse across builds
+* **Testing and validation**: When you want to manually inspect the update files that were included in the build
+
+{: .note-title}
+
+> Note
+>
+> Only the update-specific subfolders are removed-the `Apps` folder itself and other application content (unless **Remove Apps Folder Content** is also selected) are preserved.
+
+## Restore Defaults
+
+Use this to restore FFU Builder to its default state. When clicked:
+
+- A confirmation dialog lists what will be removed before anything is deleted.
+  - Generated JSON files are removed (`config\FFUConfig.json`, `Apps\AppList.json`, `Apps\UserAppList.json`, `Drivers\Drivers.json`).
+  - Capture, Deploy, and Apps ISO files are deleted.
+  - Downloaded artifacts are cleared: Apps payloads (Win32, MSStore, Office downloads), update folders under Apps (Defender, Edge, MSRT, OneDrive), driver downloads, and all `.ffu` files in the FFU capture folder.
+  - UI list views (drivers, apps, Winget search results, AppScript variables) are cleared and all controls are reset to their default values.
+
+{: .note-title}
+
+> Note
+>
+> VHDX cache and any custom config files in the `FFUDevelopment\config` folder, and `Drivers\DriverMapping.json` will remain. DriverMapping.json is retained because you may have made custom changes to it and we want to retain those.
+>
+> If you want to keep any content prior to restoring defaults, copy it out first.
+
+## Save Config File
+
+Saves all current UI selections to a JSON file so you can reload the same settings later or run `BuildFFUVM.ps1` from the command line with `-configFile` (e.g. `BuildFFUVM.ps1 -configFile C:\FFUDevelopment\config\FFUConfig.json`)
+
+### How it works
+
+- Collects the full UI state (paths, toggles, driver/app selections, build options) into a single JSON.
+- Defaults the save location to `FFUDevelopmentPath\config` and suggests `FFUConfig.json` as the file name. You can browse and pick a different file name or folder.
+- Creates the `config` folder if it does not exist and confirms the save when finished.
+
+## Load Config File
+
+Loads a previously saved configuration JSON and repopulates the UI.
+
+### How it works
+
+- Click **Load Config File** to browse for a JSON file (for example, `FFUDevelopment\config\FFUConfig.json`).
+- The UI updates with everything from the file: paths, checkboxes, build options, driver/app selections, and USB settings.
+- Supplemental files referenced in the config (Winget `AppList.json`, BYO `UserAppList.json`, `Drivers.json`) are also imported if they exist. Missing helper files are treated as optional and noted for you.
+- If the file is empty, unreadable, or invalid JSON, the load is stopped and an error message is shown.
+
+## Build FFU
+
+Use **Build FFU** to run `BuildFFUVM.ps1` with the current UI selections.
+
+### What happens when you click Build FFU
+
+- The UI gathers all current settings and saves them to `FFUDevelopment\config\FFUConfig.json`, and launches `BuildFFUVM.ps1 -configFile` pointing to that file in a background job. `FFUConfig.json` persists between builds and is read on each opening of `BuildFFUVM_UI.ps1` so you can continue where you left off on each new run.
+- The window switches to the **Monitor** tab so you can watch progress in real time.
+- The progress bar shows overall completion
+- When the job finishes, the button returns to **Build FFU** and the UI is ready for the next run.
+
+### Cancelling a Build
+
+The Build FFU button will change to Cancel while a build is running. Cancelling will do the following:
+
+- The UI stops the background build job and kills any child processes so DISM, downloads, and other tools exit.
+- The in-progress download is always removed to avoid partial or corrupt content.
+- You’re prompted to decide whether to remove other items downloaded during this run. Selecting **Yes** removes only this run’s downloads. Any previously downloaded content stays in place.
+- When cleanup is finished, the Cancel button reverts to Build FFU and a new build can begin
+
+{% include page_nav.html %}

docs/byoapps.md

@@ -0,0 +1,98 @@
+---
+title: Bring Your Own Applications
+nav_order: 6
+prev_url: /winget.html
+prev_label: Install Winget Applications
+next_url: /appsscriptvariables.html
+next_label: Apps Script Variables
+parent: Applications
+grand_parent: UI Overview
+---
+# Bring Your Own Applications
+
+![1760117497413](image/byoapps/1760117497413.png)
+
+Bring Your Own Applications allows you to run any command line you want in the virtual machine to include in your FFU to install an application, run a script, etc. As the name implies, you'll provide the content, command line, arguments, and additional exit codes.
+
+All applications are stored in the `$AppsPath` parent folder which defaults to `C:\FFUDevelopment\Apps`. Winget source applications and BYO Apps that you select Copy Apps are stored in `$AppsPath\Win32`. MSStore source apps from Winget are stored in `$AppsPath\MSStore`.
+
+At build time, an `Apps.iso` file is created of the `$AppsPath` folder. This ISO gets mounted to the VM. It shows up in the VM as the `D:\` drive. When creating your command line or arguments, you must make sure to reference `D:\`.
+
+## Name
+
+The name of the application. The name is also used when selecting **Copy Apps** to copy apps from a source location to the `$AppsPath\Win32\<Name>` folder (e.g. `C:\FFUDevelopment\Apps\Win32\Google Chrome`)
+
+## Command Line
+
+This is the full path to the command line to install the application, script, or to run a command. If the content was included in the `$AppsPath` this should start with `D:\` (e.g. `D:\Win32\Mozilla Firefox\Mozilla Firefox_136.0.3_Machine_X64_exe_en-US.exe`)
+
+For MSI applications, this should only include msiexec. The rest of the command line will be specified in arguments.
+
+## Arguments
+
+These are the command line arguments for the application. Using the Mozilla Firefox example above, the arguments would be `/S /PreventRebootRequired=true`.
+
+For MSI applications, this will include `/i` and the full-path to the MSI file plus any additional command line parameters (e.g. `/i "D:\Win32\Google Chrome\Google Chrome_134.0.6998.178_Machine_X64_wix_en-US.msi" /quiet /norestart`)
+
+## Source
+
+This is an optional parameter. This is the local source to the content. It is used by the Copy Apps button to copy from the source location to the `$AppsPath\Win32\<Name>` folder. If you don't use the **Copy Apps** button, then you must put the conent in the `$AppsPath` folder manually.
+
+## Additional Exit Codes
+
+This is an optional parameter. Enter a comma-separated list of additional success exit codes if necessary.
+
+## Ignore all non-zero exit codes
+
+If checked, any non-zero exit code will be considered a success.
+
+## Save UserAppList.json
+
+When you're done adding your apps, you must save the `UserAppList.json` file to your `$AppsPath` folder. If you click **Copy Apps**, the `UserAppList.json` file is also saved. The `UserAppList.json` is used by the FFU Builder Orchestrator in the VM to know what to install and when based on the priority of the application.
+
+Below is the `UserAppList.json` of Chrome and Firefox using the example above.
+
+```json
+[
+  {
+    "Priority": 1,
+    "Name": "Google Chrome",
+    "CommandLine": "msiexec",
+    "Arguments": "/i \"D:\\Win32\\Google Chrome\\Google Chrome_134.0.6998.178_Machine_X64_wix_en-US.msi\" /quiet /norestart",
+    "Source": "C:\\temp\\source\\Google Chrome",
+    "AdditionalExitCodes": "",
+    "IgnoreNonZeroExitCodes": false
+  },
+  {
+    "Priority": 2,
+    "Name": "Mozilla Firefox",
+    "CommandLine": "D:\\Win32\\Mozilla Firefox\\Mozilla Firefox_136.0.3_Machine_X64_exe_en-US.exe",
+    "Arguments": "/S /PreventRebootRequired=true",
+    "Source": "C:\\temp\\source\\Mozilla Firefox",
+    "AdditionalExitCodes": "",
+    "IgnoreNonZeroExitCodes": false
+  }
+]
+```
+
+## Import UserAppList.json
+
+You can import a saved `UserAppList.json`
+
+## Edit Application
+
+When you select a single application you can select the **Edit Application** button. This allows you to edit the application information and update the application.
+
+## Copy Apps
+
+If the application source is provided, click **Copy Apps** to copy the application content to the `$AppsPath\Win32` folder (e.g. `C:\FFUDevelopment\Apps\Win32\<Name>`). Network shares are supported. When clicking **Copy Apps** the `UserAppList.json` file is automatically created.
+
+## Remove Selected
+
+Removes the selected applications from the list view. Click **Save UserAppList.json** to save the application list.
+
+## Clear List
+
+The **Clear List** button will clear the list view of what’s currently in it. It will not clear the `UserAppList.json` file if it exists.
+
+{% include page_nav.html %}

docs/create_pemedia.md

@@ -0,0 +1,91 @@
+---
+title: Create PE Media
+nav_order: 1
+prev_url: /helper_scripts.html
+prev_label: Helper Scripts
+next_url: /usb_imaging_tool_creator.html
+next_label: USB Imaging Tool Creator
+parent: Helper Scripts
+---
+# Create PE Media
+
+`Create-PEMedia.ps1` is a standalone helper script that creates WinPE capture or deployment ISO files outside the main build flow.
+
+This is useful when admins need to quickly generate a deploy ISO for a share (or local staging folder) that technicians will use with `USBImagingToolCreator.ps1`.
+
+## Common use case
+
+If your staging location does not already have a deployment ISO, run `Create-PEMedia.ps1` to generate one, then copy that ISO to the staging folder used by your technicians.
+
+## Prerequisites
+
+- Run from an elevated PowerShell session.
+- Windows ADK + WinPE add-on must be installed (default path: `C:\Program Files (x86)\Windows Kits\10\`).
+- Script should be run from the `FFUDevelopment` folder (or provide explicit paths via parameters).
+
+## Quick start (deploy ISO)
+
+From `FFUDevelopment`, this creates a deploy ISO by default:
+
+```powershell
+.\Create-PEMedia.ps1
+```
+
+Default output file:
+
+- `.\WinPE_FFU_Deploy_x64.iso`
+
+## Useful commands
+
+Create deploy ISO for x64:
+
+```powershell
+.\Create-PEMedia.ps1 -Deploy $true -WindowsArch 'x64'
+```
+
+Create deploy ISO for ARM64:
+
+```powershell
+.\Create-PEMedia.ps1 -Deploy $true -WindowsArch 'arm64' -DeployISO "$PSScriptRoot\WinPE_FFU_Deploy_arm64.iso"
+```
+
+Create capture ISO only:
+
+```powershell
+.\Create-PEMedia.ps1 -Capture $true -Deploy $false
+```
+
+Create deploy ISO and include PE drivers from `.\PEDrivers`:
+
+```powershell
+.\Create-PEMedia.ps1 -Deploy $true -CopyPEDrivers $true
+```
+
+## Stage output for USB imaging
+
+After creating the deploy ISO, place it in the same staging root used for USB media creation.
+
+Example:
+
+```text
+\\Server\FFUStaging\
+  WinPE_FFU_Deploy_x64.iso
+  FFU\
+    <image files>.ffu
+  Drivers\
+    <optional driver content>
+```
+
+Then technicians can run:
+
+```powershell
+.\USBImagingToolCreator.ps1 -DeployISOPath "\\Server\FFUStaging\WinPE_FFU_Deploy_x64.iso" -DisableAutoPlay
+```
+
+## Logging
+
+`Create-PEMedia.ps1` writes log output to:
+
+- `.\Create-PEMedia.log` (or custom path via `-LogFile`)
+
+{% include page_nav.html %}

docs/drivers.md

@@ -0,0 +1,410 @@
+---
+title: Drivers
+nav_order: 9
+prev_url: /M365appsoffice.html
+prev_label: M365 Apps Office
+next_url: /build.html
+next_label: Build
+parent: UI Overview
+---
+# Drivers
+
+![1760488183854](image/drivers/1760488183854.png)
+
+FFU Builder supports adding drivers directly to the FFU file at build time, or adding them as folders on your USB drive which can be serviced offline after the FFU has been applied to your device.
+
+The UI allows you to download the drivers prior to build and/or create a `Drivers.json` file which can be used to automatically download the drivers at build time. This allows for flexibility in downloading drivers whenever you need them. It supports downloading multiple driver models at once in parallel.
+
+## Drivers Folder
+
+This is the location where drivers are downloaded to, or where you'll manually copy drivers to. The default is `.\FFUDevelopment\Drivers`
+
+## PE Drivers Folder
+
+Path to the folder containing drivers to be injected into the WinPE deployment media. Default is `.\FFUDevelopment\PEDrivers`.
+
+## Drivers.json Path
+
+Path to a JSON file that specifies which drivers to download. Default is `.\FFUDevelopment\Drivers\Drivers.json`
+
+## Download Drivers
+
+FFU Builder can download drivers from the following OEMs:
+
+* Dell
+* HP
+* Lenovo
+* Microsoft
+
+Clicking the **Download Drivers** exposes a **Make:** drop down which lists the above four OEMs and a **Get Models** button
+
+Clicking **Get Models** downloads the list of models from the selected OEM.
+
+The **Model Filter** box allows you to type in a string to filter on the model. The filter should match on any portion of text in the model name.
+
+The model column lists the model name and the System ID (for Dell and HP) or the Machine Type (for Lenovo) in parenthesis. The SystemID/Machine Type values are required to know exactly which set of drivers to download for your model. There typically is a lot of overlap, and sometimes the drivers for the various SystemID/MachineTypes for the same model might be exactly the same, it's still best to grab the SystemID/MachineType before downloading drivers.
+
+To get the System ID:
+
+**HP**
+
+* BIOS/UEFI: Either under Main or System Information (it's going to be different depending on the model) you're looking for the **System Board ID** and it should be a four-character code.
+* PowerShell:`(Get-CimInstance -Namespace 'root\WMI' -Class MS_SystemInformation).BaseboardProduct`
+
+**Dell**
+
+* BIOS/UEFI: I'm not sure if it's possible to get the System ID from the BIOS/UEFI. I seem to recall in some BIOS screenshots that System SKU is listed in some BIOS/UEFI implementations, but it may not be consistent.
+* PowerShell: `(Get-CIMInstance -ClassName "MS_SystemInformation" -NameSpace "root\WMI").SystemSku`
+
+  or
+
+  ```
+  [string]$OEMString = Get-WmiObject -Class "Win32_ComputerSystem" | Select-Object -ExpandProperty OEMStringArray
+  $ComputerDetails.FallbackSKU = [regex]::Matches($OEMString, '\[\S*]')[0].Value.TrimStart("[").TrimEnd("]")
+  ```
+
+**Lenovo**
+
+To find the Machine Type for Lenovo devices, check the bottom/back of the device for the MTM field and capture the first four characters.
+
+* BIOS/UEFI: Look for MTM and grab the first four characters
+* PowerShell: `(Get-CIMInstance -ClassName "MS_SystemInformation" -NameSpace "root\WMI").SystemProductName`
+
+You can multi-select different models within the same make, or mix and match different makes. The screenshot below shows different Dell, HP, Lenovo, and Microsoft models selected
+
+![FFU Builder UI showing multiple driver models selected for Dell, HP, Microsoft, and Lenovo](image/drivers/1763794307504.png "FFU Builder UI showing multiple driver models selected for Dell, HP, Microsoft, and Lenovo")
+
+## Save Drivers.json
+
+After selecting the drivers you want to download, clicking **Save Drivers.json** will prompt you for a location to save the `Drivers.json` file to. The `Drivers.json` file is responsible for telling `BuildFFUVM.ps1` what drivers to download during the build process.
+
+Below is an example of `Drivers.json`:
+
+```
+{
+  "HP": {
+    "Models": [
+      {
+        "Name": "HP EliteBook 865 16 inch G11 Notebook PC",
+        "SystemId": "8d03"
+      }
+    ]
+  },
+  "Dell": {
+    "Models": [
+      {
+        "Name": "Dell Pro Max Desktops Dell Pro Max Micro FCM2250,Dell Pro Max Micro XE FCM2250",
+        "CabUrl": "https://downloads.dell.com/FOLDER13898125M/1/Dell_Pro_Max_Desktops_0D14.cab",
+        "SystemId": "0D14"
+      }
+    ]
+  },
+  "Lenovo": {
+    "Models": [
+      {
+        "Name": "Lenovo 300w Yoga Gen 4",
+        "MachineType": "82VN"
+      }
+    ]
+  },
+  "Microsoft": {
+    "Models": [
+      {
+        "Name": "Surface Pro for Business (11th Edition)",
+        "Link": "https://www.microsoft.com/download/details.aspx?id=108013"
+      }
+    ]
+  }
+}
+```
+
+## Import Drivers.json
+
+Import Drivers.json allows you to import a previously saved Drivers.json file. The models in the Drivers.json file will show up in the list view pre-selected. This will allow you to select additional models and save an updated version of Drivers.json, or to download the selected models by clicking Download Selected.
+
+## Download Selected
+
+Download Selected will download the selected models to the Drivers Folder path (default .\FFUDevelopment\Drivers). Drivers will download the the .\FFUDevelopment\Drivers\Make\Model folder. Download select also interacts with the Compress Driver Model Folder to WIM checkbox which will download and compress the drivers to WIM.
+
+If you've previously downloaded a driver model and want to compress it to a WIM, you can check he Compress Driver Model Folder to WIM checkbox and click Download Selected again. This will skip the download and compress the driver folder to a WIM file.
+
+Download Selected leverages BITS and the BITS Priority can be controlled by the BITS Priority drop down on the Build tab. If driver downloads via the UI feel slow, change BITS Priority to Foreground to speed them up.
+
+## Clear List
+
+Clears the list view of the previous model list
+
+## Install Drivers to FFU
+
+Install Drivers to FFU will recursively add the drivers in the FFUDevelopment\Drivers folder to the FFU file.
+
+It's recommended to only include a single model's drivers in the FFU. This is because dism will add the drivers to the drivers store in the FFU and any additional models that aren't necessary will bloat the drivers store, using up disk space.
+
+If you're dealing with multiple models, it's recommended to select Copy Drivers to USB drive instead.
+
+## Copy Drivers to USB drive
+
+Copy Drivers to USB drive will copy the drivers to the .\Drivers folder on the deploy partition of the USB drive (e.g. D:\Drivers\Make\Model)
+
+If you're manually copying drivers to the .\FFUDevelopment\Drivers folder, you must copy them to the FFUDevelopment\Drivers\Make\Model folder (e.g. FFUDevelopment\Drivers\Lenovo\Lenovo 300w). Prior releases referenced using just .\FFUDevelopment\Drivers\Model, however for better organization and consistency, the code has been updated to require the make folder.
+
+## Compress Driver Model Folder to WIM
+
+Enabling this checkbox compresses the driver model folder to a WIM file after each model finishes downloading (or when an existing model is detected). Every `Drivers\<Make>\<Model>` directory is captured into a single `<Drivers folder>\<Make>\<Model>.wim` using DISM with `Compress:Max`, which dramatically reduces the space required on your USB drive.
+
+1. Select the models you need, check **Compress Driver Model Folder to WIM**, then click **Download Selected**. Fresh downloads are extracted as usual and immediately compressed into their companion `.wim`.
+2. If the model already exists, the download phase is skipped and only the compression runs, so you can rebuild the `.wim` whenever you refresh the folder contents.
+
+By default the extracted folder is deleted after a successful capture so that the `.wim` becomes the canonical artifact. When **Use Drivers Folder as PE Drivers Source** is also checked, the UI keeps the folder in place, writes a `__PreservedForPEDrivers.txt` marker, and lets WinPE driver harvesting reuse the loose INF set.
+
+Additional guidance:
+
+- `DriverMapping.json` is updated to reference the `.wim`, so `Copy Drivers to USB drive`, `BuildFFUVM.ps1 -CopyDrivers`, and the WinPE `ApplyFFU.ps1` flow mount the compressed archive automatically.
+- Watch the Drivers tab status column or `FFUDevelopment_UI.log` for DISM progress and troubleshooting details per model.
+- Ensure the volume hosting `FFUDevelopment\Drivers` has enough free space for both the source folder and the resulting `.wim`.
+- Only applies to drivers from Dell, HP, Lenovo, or Microsoft that are specified in the Drivers.json file. It will not compress models you manually copy to the Drivers folder.
+
+## Copy PE Drivers
+
+When **Copy PE Drivers** is enabled, drivers will be injected into the WinPE deployment media. This ensures that WinPE has the necessary drivers to recognize hardware components like storage controllers, network adapters, and input devices during FFU deployment.
+
+By default, drivers are sourced from the **PE Drivers Folder** (default `.\FFUDevelopment\PEDrivers`). You can manually place drivers in this folder, and they will be injected into the WinPE media during the build process.
+
+### Use Drivers Folder as PE Drivers Source
+
+When **Copy PE Drivers** is checked, an additional sub-option becomes visible:  **Use Drivers Folder as PE Drivers Source** .
+
+When this option is enabled, the script bypasses the PE Drivers Folder and instead dynamically builds the WinPE driver set from the main **Drivers Folder**. The script scans all available drivers in the Drivers folder, parses their INF files, and copies only the essential driver types needed for WinPE, including:
+
+* System devices
+* SCSI, RAID, and NVMe controllers
+* Keyboards
+* Mice and other pointing devices
+* Human Interface Devices (HID) for touch support
+
+This eliminates the need to maintain a separate, manually curated `PEDrivers` folder and ensures that WinPE has the necessary drivers based on what you've already downloaded for your target devices.
+
+{: .note-title}
+
+> Note
+>
+> If the PE Drivers folder already contains content when using this option, it will be cleared before the new driver set is copied in.
+>
+> Some drivers may fail to be added during injection, which is expected behavior and can be safely ignored.
+>
+> Network adapters are not included when using the drivers folder as PE drivers source, so if you're using WDS or another network-based solution to copy your FFU and you've modified ApplyFFU.ps1, it's best to not use the **Use Drivers Folder as PE Driver Source** option and just copy in your required PE Drivers to the PE Drivers folder.
+
+## DriverMapping.json
+
+`DriverMapping.json` is an automatically generated file that maps hardware identifiers (like System IDs or Machine Types) to specific driver packages. This file enables the WinPE deployment script (`ApplyFFU.ps1`) to automatically detect your device hardware and apply the correct drivers without manual intervention.
+
+### How it gets created
+
+`DriverMapping.json` is created and updated automatically when you download drivers using the **Download Selected** button on the Drivers tab of the UI, or when drivers are downloaded during the FFU build. Each time you successfully download drivers for a model, the file is updated with the mapping information for that model.
+
+### Automatic Driver Selection During Deployment
+
+When you deploy an FFU using the WinPE media, `ApplyFFU.ps1` looks for `DriverMapping.json` on the USB drive at `D:\Drivers\DriverMapping.json` (where D: is your USB deploy partition). If found, the script:
+
+1. Detects the hardware identifiers of the current device (System ID, Machine Type, etc.)
+2. Searches `DriverMapping.json` for a matching entry
+3. Automatically selects and applies the correct driver package
+4. Falls back to manual driver selection if no match is found
+
+### Required Fields by Manufacturer
+
+Each entry in `DriverMapping.json` contains different required fields depending on the manufacturer:
+
+**All Manufacturers:**
+
+* **Manufacturer** – The OEM name (e.g., "Dell", "HP", "Lenovo", "Microsoft")
+* **Model** – The full model name as it appears in the driver download catalog
+* **DriverPath** – The relative path to the driver folder or WIM file on the USB drive under the Drivers folder (e.g., "Dell\\\Dell Latitude 7490" or "HP\\\HP EliteBook 865 16 inch G11 Notebook PC.wim").
+
+  Relative paths are used since we don't know the drive letter of the USB drive when the `DriverMapping.json` file is created. And since this uses json, the double backslash is intentional since the first slash is an escape character.
+
+**Dell:**
+
+* **SystemId** – The System SKU identifier (e.g., "0819", "0D14"). This is the primary matching field used during deployment. To find your Dell System SKU via PowerShell, run: `(Get-CIMInstance -ClassName "MS_SystemInformation" -NameSpace "root\WMI").SystemSku`
+
+**HP:**
+
+* **SystemId** – The System Board ID, a four-character code (e.g., "8d03", "83D2"). This is the primary matching field used during deployment. To find your HP System Board ID via PowerShell, run: `(Get-CimInstance -Namespace 'root\WMI' -Class MS_SystemInformation).BaseboardProduct`
+
+**Lenovo:**
+
+* **MachineType** – The first four characters of the MTM (Machine Type Model) field (e.g., "82VN", "21JD"). This is the primary matching field used during deployment. To find your Lenovo Machine Type via PowerShell, run: `(Get-CIMInstance -ClassName "MS_SystemInformation" -NameSpace "root\WMI").SystemProductName`
+
+**Microsoft:**
+
+* No additional fields required beyond Manufacturer, Model, and DriverPath. Matching is performed based on the normalized model name.
+
+### Example DriverMapping.json
+
+Below is an example of `DriverMapping.json` with entries for multiple manufacturers:
+
+```
+[
+  {
+    "Manufacturer": "Dell",
+    "Model": "Dell Latitude 7490",
+    "DriverPath": "Dell\\Dell Latitude 7490",
+    "SystemId": "0819"
+  },
+  {
+    "Manufacturer": "Dell",
+    "Model": "Dell Pro Max Desktops Dell Pro Max Micro FCM2250,Dell Pro Max Micro XE FCM2250",
+    "DriverPath": "Dell\\Dell Pro Max Desktops Dell Pro Max Micro FCM2250,Dell Pro Max Micro XE FCM2250.wim",
+    "SystemId": "0D14"
+  },
+  {
+    "Manufacturer": "HP",
+    "Model": "HP EliteBook 865 16 inch G11 Notebook PC",
+    "DriverPath": "HP\\HP EliteBook 865 16 inch G11 Notebook PC.wim",
+    "SystemId": "8D03"
+  },
+  {
+    "Manufacturer": "Lenovo",
+    "Model": "Lenovo 300w Yoga Gen 4",
+    "DriverPath": "Lenovo\\Lenovo 300w Yoga Gen 4",
+    "MachineType": "82VN"
+  },
+  {
+    "Manufacturer": "Microsoft",
+    "Model": "Surface Pro for Business (11th Edition)",
+    "DriverPath": "Microsoft\\Surface Pro for Business (11th Edition)"
+  }
+]
+```
+
+## Bring Your Own Drivers
+
+If you manage models that aren't from Dell, HP, Lenovo or Microsoft, or you want to use different drivers from what FFU Builder downloads, you can copy your own drivers to the `.\FFUDevelopment\Drivers` folder using the `.\FFUDevelopment\Drivers\Make\Model` format, or simply change the Drivers Folder path to the location of your drivers content.
+
+You can also manually create your own DriverMapping.json file for the following makes/manufacturers
+
+| Manufacturer                    | Match Field | WMI Class                                   | Property                                        |
+| ------------------------------- | ----------- | ------------------------------------------- | ----------------------------------------------- |
+| **Dell**                  | SystemId    | `MS_SystemInformation` (via `root\WMI`) | `SystemSku`                                   |
+| **Dell** (fallback)       | SystemId    | `Win32_ComputerSystem`                    | `OEMStringArray` (parsed for bracketed value) |
+| **HP**                    | SystemId    | `MS_SystemInformation` (via `root\WMI`) | `BaseBoardProduct`                            |
+| **Lenovo**                | MachineType | `Win32_ComputerSystem`                    | `Model`                                       |
+| **Microsoft**             | Model       | `Win32_ComputerSystem`                    | `Model`                                       |
+| **Panasonic Corporation** | SystemId    | `MS_SystemInformation` (via `root\WMI`) | `BaseBoardProduct`                            |
+| **Viglen**                | SystemId    | `Win32_BaseBoard`                         | `SKU`                                         |
+| **AZW**                   | SystemId    | `MS_SystemInformation` (via `root\WMI`) | `BaseBoardProduct`                            |
+| **Fujitsu**               | SystemId    | `Win32_BaseBoard`                         | `SKU`                                         |
+| **Getac**                 | SystemId    | `MS_SystemInformation` (via `root\WMI`) | `BaseBoardProduct`                            |
+| **Intel**                 | Model       | `Win32_ComputerSystem`                    | `Model`                                       |
+| **ByteSpeed**             | Model       | `Win32_ComputerSystem`                    | `Model`                                       |
+| **Other** (default)       | Model       | `Win32_ComputerSystem`                    | `Model`                                       |
+
+**Notes:**
+
+* Match Field is the name of the field in the `DriverMapping.json` file (e.g. SystemID, MachineType, Model)
+* SystemId is a catch-all term for a unique identifier, however each manufacturer calls this something different and stores them in different places within WMI
+* The Dell (fallback) is used for models where the systemSKU isn't available and the OEMStringArray is parsed via Win32_ComputerSystem
+* The `MS_SystemInformation` class is queried from the `root\WMI` namespace
+* Unless noted, the other WMI classes use the `root\cimv2` namespace
+* All identifiers are normalized to uppercase for matching
+* ByteSpeed systems with "NUC" in the model name are re-mapped to Intel and use `BaseBoardProduct` instead
+* For manufacturers that aren't listed, the default behavior is to use the `Win32_ComputerSystem` `model` string
+
+Below is an example `DriverMapping.json` that includes the additional manufacturers. Note that the model and systemID information is made up and is used only as an example to show how to format the file. You'll need to collect the model or system ID from the locations in the table above and include it in your custom `DriverMapping.json` file. Each entry includes both a WIM and drivers folder for each manufacturer. If you want to include driver WIM files for manufacturers other than Dell, HP, Lenovo, or Microsoft, you'll need to manually compress the drivers folder to a WIM file.
+
+```
+[
+    {
+        "Manufacturer": "Panasonic",
+        "Model": "Toughbook CF-33",
+        "SystemId": "CF-33LEHAGT1",
+        "DriverPath": "Panasonic\\CF-33.wim"
+    },
+    {
+        "Manufacturer": "Panasonic",
+        "Model": "Toughbook FZ-55",
+        "SystemId": "FZ-55DZ0KVM",
+        "DriverPath": "Panasonic\\FZ-55"
+    },
+    {
+        "Manufacturer": "Viglen",
+        "Model": "Genie Desktop Pro",
+        "SystemId": "VGN-GDP-2024",
+        "DriverPath": "Viglen\\GeniePro"
+    },
+    {
+        "Manufacturer": "Viglen",
+        "Model": "Omnino Mini",
+        "SystemId": "VGN-OMN-M1",
+        "DriverPath": "Viglen\\OmninoMini.wim"
+    },
+    {
+        "Manufacturer": "AZW",
+        "Model": "SER5 Pro",
+        "SystemId": "SER5-5800H",
+        "DriverPath": "AZW\\SER5Pro.wim"
+    },
+    {
+        "Manufacturer": "AZW",
+        "Model": "U59 Mini PC",
+        "SystemId": "U59-N5095",
+        "DriverPath": "AZW\\U59"
+    },
+    {
+        "Manufacturer": "Fujitsu",
+        "Model": "LIFEBOOK U9312",
+        "SystemId": "FPCM52921",
+        "DriverPath": "Fujitsu\\LIFEBOOK-U9312"
+    },
+    {
+        "Manufacturer": "Fujitsu",
+        "Model": "ESPRIMO D7010",
+        "SystemId": "D3644-A1",
+        "DriverPath": "Fujitsu\\D7010.wim"
+    },
+    {
+        "Manufacturer": "Getac",
+        "Model": "F110 G6",
+        "SystemId": "F110G6",
+        "DriverPath": "Getac\\F110G6.wim"
+    },
+    {
+        "Manufacturer": "Getac",
+        "Model": "B360 Pro",
+        "SystemId": "B360PRO",
+        "DriverPath": "Getac\\B360Pro"
+    },
+    {
+        "Manufacturer": "Intel",
+        "Model": "NUC13ANHi7",
+        "DriverPath": "Intel\\NUC13"
+    },
+    {
+        "Manufacturer": "Intel",
+        "Model": "NUC12WSHi5",
+        "DriverPath": "Intel\\NUC12.wim"
+    },
+    {
+        "Manufacturer": "ByteSpeed",
+        "Model": "Tera 2450",
+        "DriverPath": "ByteSpeed\\Tera2450.wim"
+    },
+    {
+        "Manufacturer": "ByteSpeed",
+        "Model": "Celeritas X1",
+        "DriverPath": "ByteSpeed\\CeleritasX1"
+    },
+    {
+        "Manufacturer": "Acer",
+        "Model": "TravelMate P214-53",
+        "DriverPath": "Acer\\TMP214"
+    },
+    {
+        "Manufacturer": "ASUS",
+        "Model": "ExpertBook B5402CVA",
+        "DriverPath": "ASUS\\B5402.wim"
+    }
+]
+```
+
+{% include page_nav.html %}

docs/helper_scripts.md

@@ -0,0 +1,20 @@
+---
+title: Helper Scripts
+nav_order: 4
+prev_url: /ui_overview.html
+prev_label: UI Overview
+next_url: /create_pemedia.html
+next_label: Create PE Media
+has_children: true
+has_toc: false
+---
+# Helper Scripts
+
+This section documents standalone helper scripts used outside the primary UI-driven build workflow.
+
+## Available helper scripts
+
+- [Create PE Media](/create_pemedia.html)
+- [USB Imaging Tool Creator](/usb_imaging_tool_creator.html)
+
+{% include page_nav.html %}

docs/hyperv_settings.md

@@ -0,0 +1,50 @@
+---
+title: Hyper-V Settings
+nav_order: 1
+prev_url: /ui_overview.html
+prev_label: UI Overview
+next_url: /windows_settings.html
+next_label: Windows Settings
+parent: UI Overview
+---
+# Hyper-V Settings
+
+![1759533067934](image/ui_overview/1759533067934.png)
+
+## VM Switch Name
+
+Drop down of detected VM Switches. There's also an **Other** option which allows you to specify a VM Switch Name. The other option is useful in scenarios where the machine you're running the UI from isn't going to be the machine where you plan to build the FFU from.
+
+## VM Host IP Address
+
+IP address of the selected Hyper-V switch that will be used for FFU capture. The UI will auto-detected this based on the VM Switch that was selected.
+
+If `$InstallApps` is set to `$true`, this parameter must be configured.
+
+## Disk Size (GB)
+
+Size of the virtual hard disk for the virtual machine. Default is a 50GB dynamic disk. You may want to increase the size if you're installing many apps.
+
+## Memory (GB)
+
+Amount of memory to allocate for the virtual machine. Recommended to use 8GB if possible, especially for Windows 11. Default is 4GB.
+
+## Processors
+
+Number of virtual processors for the virtual machine. Recommended to use at least 4. Default is 4.
+
+## VM Location
+
+Default is `$FFUDevelopmentPath\VM`. This is the location of the VHDX that gets created where Windows will be installed to.
+
+## VM Name Prefix
+
+Prefix for the generated VM. Default is _FFU.
+
+## Logical Sector Size
+
+Uint32 value of 512 or 4096. Useful for 4Kn drives or devices shipping with UFS drives. Default is 512.
+
+There is some error-handling in the script that will call out mismatch issues with logical sector size. Unfortunately you will need to create a new FFU with the correct logical sector size as you can't convert a previously created FFU. Most should be fine with 512, but lower-end devices that used to ship with eMMC drives have now shifted to using UFS.
+
+{% include page_nav.html %}

docs/index.md

@@ -0,0 +1,27 @@
+---
+title: Home
+nav_order: 0
+next_url: /prerequisites.html
+next_label: Prerequisites
+---
+# Using Full Flash Update (FFU) files to speed up Windows deployment
+
+What if you could have a Windows image (Windows 10/11 or Server) that has:
+
+- The latest Windows cumulative update
+- The latest .NET cumulative update
+- The latest Windows Defender Platform and Definition Updates
+- The latest version of Microsoft Edge
+- The latest version of OneDrive (Per-Machine)
+- The latest version of Microsoft 365 Apps/Office
+- The latest drivers from any of the major OEMs (Dell, HP, Lenovo, Microsoft) (yes, the latest, not some out of date enterprise CAB file from years ago)
+- Winget support so you can integrate any app available from Winget directly in your image
+- ARM64 support for the latest Copilot+ PCs
+- The ability to bring your own drivers and apps if necessary
+- Custom WinRE support
+
+And the best part: it takes **less than two minutes to apply the image**, even with all of these updates added to the media. After setting Windows up and going through Autopilot or a provisioning package, total elapsed time ~10 minutes (depending on what Intune or your device management tool is deploying).
+
+The Full-Flash update (FFU) process can automatically download the latest release of Windows 11, the updates mentioned above, and creates a USB drive that can be used to quickly reimage a machine.
+
+{% include page_nav.html %}

docs/monitor.md

@@ -0,0 +1,18 @@
+---
+title: Monitor
+nav_order: 11
+prev_url: /build.html
+prev_label: Build
+parent: UI Overview
+---
+# Monitor
+
+![1770683109457](image/monitor/1770683109457.png)
+
+The monitor tab parses the `.\FFUDevelopment\FFUDevelopment.log` file. This makes it easy to track what's happening during the FFU build process.
+
+You can click into the monitor and select one or multiple lines (either single click, or shift+click). Doing so will prevent the log file from continuous scrolling, allowing you time to read what has transpired up to that point.
+
+You can also copy your selection using ctrl+C. This makes it easy to copy and paste parts of the log file used for troubleshooting. 
+
+{% include page_nav.html %}

docs/parameters_reference.md

@@ -0,0 +1,102 @@
+---
+title: Parameters Reference
+nav_order: 1
+parent: Reference
+prev_url: /reference.html
+prev_label: Reference
+---
+# BuildFFUVM.ps1 Parameter Reference
+
+This table lists all top-level parameters in BuildFFUVM.ps1.
+
+<style>
+.parameters-reference-table th:first-child,
+.parameters-reference-table td:first-child {
+    white-space: nowrap;
+}
+</style>
+
+| Parameter | Type | UI Control | Description |
+| --- | --- | --- | --- |
+| -AdditionalFFUFiles | string[] | Copy Additional FFU Files + Additional FFU Files list | Array of full file paths to existing FFU files that should also be copied to the deployment USB when -CopyAdditionalFFUFiles is set to $true. |
+| -AllowExternalHardDiskMedia | bool | Allow External Hard Disk Media | When set to $true, will allow the use of media identified as External Hard Disk media via WMI class Win32_DiskDrive. Default is not defined. |
+| -AllowVHDXCaching | bool | Allow VHDX Caching | When set to $true, will cache the VHDX file to the $FFUDevelopmentPath\VHDXCache folder and create a config json file that will keep track of the Windows build information, the updates installed, and the logical sector byte size information. Default is $false. |
+| -AppListPath | string | AppList.json Path | Path to a JSON file containing a list of applications to install using WinGet. Default is $FFUDevelopmentPath\Apps\AppList.json. |
+| -AppsScriptVariables | hashtable | Define Apps Script Variables + Apps Script Variables list | When passed a hashtable, the script will create an AppsScriptVariables.json file in the OrchestrationPath. This file will be used to pass variables to the Apps script. The hashtable should contain key-value pairs where the key is the variable name and the value is the variable value. |
+| -BitsPriority | string | BITS Priority | BITS transfer priority used for downloads. Accepted values are 'Foreground', 'High', 'Normal', and 'Low'. Default is 'Normal'. |
+| -BuildUSBDrive | bool | Build USB Drive | When set to $true, will partition and format a USB drive and copy the captured FFU to the drive. |
+| -Cleanup | switch | Monitor cancel build action (no direct control) | Switch to run cleanup-only mode. When specified, the script performs cleanup and exits without starting a new build. |
+| -CleanupAppsISO | bool | Cleanup Apps ISO | When set to $true, will remove the Apps ISO after the FFU has been captured. Default is $true. |
+| -CleanupCaptureISO | bool | Cleanup Capture ISO | When set to $true, will remove the WinPE capture ISO after the FFU has been captured. Default is $true. |
+| -CleanupCurrentRunDownloads | bool | Monitor cancel prompt option (no direct control) | When set to $true, cleanup mode will remove downloads created during the current run and restore backed up run JSON files. Default is $false. |
+| -CleanupDeployISO | bool | Cleanup Deploy ISO | When set to $true, will remove the WinPE deployment ISO after the FFU has been captured. Default is $true. |
+| -CleanupDrivers | bool | Cleanup Drivers | When set to $true, will remove the drivers folder after the FFU has been captured. Default is $true. |
+| -CompactOS | bool | Compact OS | When set to $true, will compact the OS when building the FFU. Default is $true. |
+| -CompressDownloadedDriversToWim | bool | Compress Driver Model Folder to WIM | When set to $true, compresses downloaded drivers into a WIM file. Default is $false. |
+| -ConfigFile | string | Load Config File | Path to a JSON file containing parameters to use for the script. Default is $null. |
+| -CopyAdditionalFFUFiles | bool | Copy Additional FFU Files | When set to $true, enables copying additional FFU files from $FFUDevelopmentPath\FFU to the deployment USB alongside the current build output. |
+| -CopyAutopilot | bool | Copy Autopilot Profile | When set to $true, will copy the $FFUDevelopmentPath\Autopilot folder to the Deployment partition of the USB drive. Default is $false. |
+| -CopyDrivers | bool | Copy Drivers to USB drive | When set to $true, will copy the drivers from the $FFUDevelopmentPath\Drivers folder to the Drivers folder on the deploy partition of the USB drive. Default is $false. |
+| -CopyPEDrivers | bool | Copy PE Drivers | When set to $true, enables adding WinPE drivers. By default copies drivers from $FFUDevelopmentPath\PEDrivers to the WinPE deployment media unless -UseDriversAsPEDrivers is also $true. |
+| -CopyPPKG | bool | Copy Provisioning Package | When set to $true, will copy the provisioning package from the $FFUDevelopmentPath\PPKG folder to the Deployment partition of the USB drive. Default is $false. |
+| -CopyUnattend | bool | Copy Unattend.xml | When set to $true, will copy the $FFUDevelopmentPath\Unattend folder to the Deployment partition of the USB drive. Default is $false. |
+| -CreateCaptureMedia | bool | Create Capture Media | When set to $true, this will create WinPE capture media for use when $InstallApps is set to $true. This capture media will be automatically attached to the VM, and the boot order will be changed to automate the capture of the FFU. |
+| -CreateDeploymentMedia | bool | Create Deployment Media | When set to $true, this will create WinPE deployment media for use when deploying to a physical device. |
+| -CustomFFUNameTemplate | string | Custom FFU Name Template | Sets a custom FFU output name with placeholders. Allowed placeholders are: {WindowsRelease}, {WindowsVersion}, {SKU}, {BuildDate}, {yyyy}, {MM}, {dd}, {H}, {hh}, {mm}, {tt}. |
+| -Disksize | uint64 | Disk Size (GB) | Size of the virtual hard disk for the virtual machine. Default is a 50GB dynamic disk. |
+| -DriversFolder | string | Drivers Folder | Path to the drivers folder. Default is $FFUDevelopmentPath\Drivers. |
+| -DriversJsonPath | string | Drivers.json Path | Path to a JSON file that specifies which drivers to download. |
+| -ExportConfigFile | string | Save Config File | Path to a JSON file to export the parameters used for the script. |
+| -FFUCaptureLocation | string | FFU Capture Location | Path to the folder where the captured FFU will be stored. Default is $FFUDevelopmentPath\FFU. |
+| -FFUDevelopmentPath | string | FFU Development Path | Path to the FFU development folder. Default is $PSScriptRoot. |
+| -FFUPrefix | string | VM Name Prefix | Prefix for the generated FFU file. Default is _FFU. |
+| -Headers | hashtable | CLI only (no UI control) | Headers to use when downloading files. Not recommended to modify. |
+| -InjectUnattend | bool | Inject Unattend.xml | When set to $true and InstallApps is also $true, copies unattend_[arch].xml from $FFUDevelopmentPath\unattend to $FFUDevelopmentPath\Apps\Unattend\Unattend.xml so sysprep can use it inside the VM. Default is $false. |
+| -InstallApps | bool | Install Applications | When set to $true, the script will create an Apps.iso file from the $FFUDevelopmentPath\Apps folder. It will also create a VM, mount the Apps.iso, install the apps, sysprep, and capture the VM. When set to $false, the FFU is created from a VHDX file, and no VM is created. |
+| -InstallDrivers | bool | Install Drivers to FFU | Install device drivers from the specified $FFUDevelopmentPath\Drivers folder if set to $true. Download the drivers and put them in the Drivers folder. The script will recurse the drivers folder and add the drivers to the FFU. |
+| -InstallOffice | bool | Install Office | Install Microsoft Office if set to $true. The script will download the latest ODT and Office files in the $FFUDevelopmentPath\Apps\Office folder and install Office in the FFU via VM. |
+| -ISOPath | string | Windows ISO Path | Path to the Windows 10/11 ISO file. |
+| -LogicalSectorSizeBytes | uint32 | Logical Sector Size | UInt32 value of 512 or 4096. Useful for 4Kn drives or devices shipping with UFS drives. Default is 512. |
+| -Make | string | Make | Make of the device to download drivers. Accepted values are: 'Microsoft', 'Dell', 'HP', 'Lenovo'. |
+| -MaxUSBDrives | int | Max USB Drives | Maximum number of USB drives to build in parallel. Default is 5. Set to 0 to process all discovered drives (or all selected drives when USBDriveList or selection is used). Actual throttle will never exceed the number of drives discovered. |
+| -MediaType | string | Media Type | String value of either 'business' or 'consumer'. This is used to identify which media type to download. Default is 'consumer'. |
+| -Memory | uint64 | Memory (GB) | Amount of memory to allocate for the virtual machine. Recommended to use 8GB if possible, especially for Windows 11. Default is 4GB. |
+| -Model | string | Driver Models list | Model of the device to download drivers. This is required if Make is set. |
+| -OfficeConfigXMLFile | string | Office Configuration XML File | Path to a custom Office configuration XML file to use for installation. |
+| -Optimize | bool | Optimize | When set to $true, will optimize the FFU file. Default is $true. |
+| -OptionalFeatures | string | Optional Features | Provide a semicolon-separated list of Windows optional features you want to include in the FFU (e.g., netfx3;TFTP). |
+| -OrchestrationPath | string | Application Path (derived Orchestration path) | Path to the orchestration folder containing scripts that run inside the VM. Default is $FFUDevelopmentPath\Apps\Orchestration. |
+| -PEDriversFolder | string | PE Drivers Folder | Path to the folder containing drivers to be injected into the WinPE deployment media. Default is $FFUDevelopmentPath\PEDrivers. |
+| -Processors | int | Processors | Number of virtual processors for the virtual machine. Recommended to use at least 4. |
+| -ProductKey | string | Product Key | Product key for the Windows edition specified in WindowsSKU. This will overwrite whatever SKU is entered for WindowsSKU. Recommended to use if you want to use a MAK or KMS key to activate Enterprise or Education. If using VL media instead of consumer media, you'll want to enter a MAK or KMS key here. |
+| -PromptExternalHardDiskMedia | bool | Prompt for External Hard Disk Media | When set to $true, will prompt the user to confirm the use of media identified as External Hard Disk media via WMI class Win32_DiskDrive. Default is $true. |
+| -RemoveApps | bool | Remove Apps Folder Content | When set to $true, will remove the application content in the Apps folder after the FFU has been captured. Default is $true. |
+| -RemoveFFU | bool | Remove FFU | When set to $true, will remove the FFU file from the $FFUDevelopmentPath\FFU folder after it has been copied to the USB drive. Default is $false. |
+| -RemoveUpdates | bool | Remove Downloaded Update Files | When set to $true, will remove the downloaded CU, MSRT, Defender, Edge, OneDrive, and .NET files downloaded. Default is $true. |
+| -ShareName | string | Share Name | Name of the shared folder for FFU capture. The default is FFUCaptureShare. This share will be created with rights for the user account. When finished, the share will be removed. |
+| -Threads | int | Threads | Controls the throttle applied to parallel tasks inside the script. Default is 5, matching the UI Threads field, and applies to driver downloads invoked through Invoke-ParallelProcessing. |
+| -UpdateADK | bool | Update ADK | When set to $true, the script will check for and install the latest Windows ADK and WinPE add-on if they are not already installed or up-to-date. Default is $true. |
+| -UpdateEdge | bool | Update Edge | When set to $true, will download and install the latest Microsoft Edge. Default is $false. |
+| -UpdateLatestCU | bool | Update Latest Cumulative Update | When set to $true, will download and install the latest cumulative update. Default is $false. |
+| -UpdateLatestDefender | bool | Update Defender | When set to $true, will download and install the latest Windows Defender definitions and Defender platform update. Default is $false. |
+| -UpdateLatestMicrocode | bool | Update Latest Microcode (for LTSC/Server 2016/2019) | When set to $true, will download and install the latest microcode updates for applicable Windows releases (e.g., Windows Server 2016/2019, Windows 10 LTSC 2016/2019) into the FFU. Default is $false. |
+| -UpdateLatestMSRT | bool | Update Microsoft Software Removal Tool (MSRT) | When set to $true, will download and install the latest Windows Malicious Software Removal Tool. Default is $false. |
+| -UpdateLatestNet | bool | Update .NET | When set to $true, will download and install the latest .NET Framework. Default is $false. |
+| -UpdateOneDrive | bool | Update OneDrive (Per-Machine) | When set to $true, will download and install the latest OneDrive and install it as a per-machine installation instead of per-user. Default is $false. |
+| -UpdatePreviewCU | bool | Update Preview Cumulative Update | When set to $true, will download and install the latest Preview cumulative update. Default is $false. |
+| -USBDriveList | hashtable | USB Drives list | A hashtable containing USB drives from win32_diskdrive where:<br>- Key: USB drive model name (partial match supported)<br>- Value: USB drive UniqueId string, or an array of UniqueIds (to support selecting multiple drives with the same model)<br><br>Examples:<br>@{ "SanDisk Ultra" = "1234567890" }<br>@{ "SanDisk Ultra" = @("1234567890", "ABCDEFG"); "Kingston DataTraveler" = "0987654321" } |
+| -UseDriversAsPEDrivers | bool | Use Drivers Folder as PE Drivers Source | When set to $true (and -CopyPEDrivers is also $true), bypasses the contents of $FFUDevelopmentPath\PEDrivers and instead builds the WinPE driver set dynamically from the $DriversFolder path, copying only the required WinPE drivers. Has no effect if -CopyPEDrivers is not specified. Default is $false. |
+| -UserAgent | string | CLI only (no UI control) | User agent string to use when downloading files. |
+| -UserAppListPath | string | Application Path (derived UserAppList.json) | Path to a JSON file containing a list of user-defined applications to install. Default is $FFUDevelopmentPath\Apps\UserAppList.json. |
+| -Username | string | Username | Username for accessing the shared folder. The default is ffu_user. The script will auto-create the account and password. When finished, it will remove the account. |
+| -VMHostIPAddress | string | VM Host IP Address | IP address of the Hyper-V host for FFU capture. If $InstallApps is set to $true, this parameter must be configured. You must manually configure this, or use the UI to auto-detect. |
+| -VMLocation | string | VM Location | Default is $FFUDevelopmentPath\VM. This is the location of the VHDX that gets created where Windows will be installed to. |
+| -VMSwitchName | string | VM Switch Name + Custom VM Switch Name (when Other selected) | Name of the Hyper-V virtual switch. If $InstallApps is set to $true, this must be set to capture the FFU from the VM. |
+| -WindowsArch | string | Windows Architecture | String value of 'x86', 'x64', or 'arm64'. This is used to identify which architecture of Windows to download. Default is 'x64'. |
+| -WindowsLang | string | Windows Language | String value in language-region format (e.g., 'en-us'). This is used to identify which language of media to download. Default is 'en-us'. |
+| -WindowsRelease | int | Windows Release | Integer value of 10, 11, 2016, 2019, 2021, 2022, 2024, or 2025. This is used to identify which Windows client/LTSC/server release to use. Default is 11. |
+| -WindowsSKU | string | Windows SKU | Edition/SKU to install. Accepted values are: 'Home', 'Home N', 'Home Single Language', 'Education', 'Education N', 'Pro', 'Pro N', 'Pro Education', 'Pro Education N', 'Pro for Workstations', 'Pro N for Workstations', 'Enterprise', 'Enterprise N', 'Enterprise 2016 LTSB', 'Enterprise N 2016 LTSB', 'Enterprise LTSC', 'Enterprise N LTSC', 'IoT Enterprise LTSC', 'IoT Enterprise N LTSC', 'Standard', 'Standard (Desktop Experience)', 'Datacenter', 'Datacenter (Desktop Experience)'. |
+| -WindowsVersion | string | Windows Version | String value of the Windows version to download. This is used to identify which version of Windows to download. Default is '25h2'. |
+{: .parameters-reference-table }
+
+{% include page_nav.html %}

docs/prerequisites.md

@@ -0,0 +1,66 @@
+---
+title: Prerequisites
+nav_order: 1
+prev_url: /
+prev_label: Home
+next_url: /quickstart.html
+next_label: Quick Start
+---
+# Prerequisites
+
+## Recommendations
+
+If possible, use an unmanaged Windows 11 or Windows Server machine. In some environments we see security software (AV, EDR, Firewall, etc.) get in the way and cause issues with FFU Builder successfully completing a build.
+
+### Disk space
+
+FFU Builder creates a 50GB dynamic VHDX disk by default which can be configured larger if that's not big enough. When the latest updated Windows media is installed to the VHDX, the VHDX size by itself will be about 15GB or so. If you service the media with the latest CU, that could grow the VHDX by double (~30GB in this case). If you install Office, additional applications, drivers, etc. the VHDX can get large quick. The FFU capture process will compress the size significantly, but between the VHDX size, the Windows media, the application and driver source content, the captured FFU, WinPE, etc. you can easily have over 100GB of used space.
+
+So err on the side of having more free disk space. **Recommended to have at least 100GB free disk space**.
+
+## Enable Hyper-V
+
+Follow the guide linked below to install Hyper-V on Windows client or Server
+
+[Install Hyper-V in Windows and Windows Server \| Microsoft Learn](https://learn.microsoft.com/en-us/windows-server/virtualization/hyper-v/get-started/Install-Hyper-V?tabs=gui&pivots=windows)
+
+## Install PowerShell 7
+
+PowerShell 7 is required as of releases 2507+ onward.
+
+[Installing PowerShell on Windows - PowerShell \| Microsoft Learn
+](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-windows)
+
+Recommended to use winget to install
+
+`winget install --id Microsoft.PowerShell --source winget`
+
+If you can't use winget, [download the MSI](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-windows#installing-the-msi-package)
+
+**Do not** use the Windows Store version as it has some [known limitations](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell-on-windows?view=powershell-7.5#known-limitations)
+
+## Create Hyper-V Switch
+
+Once Hyper-V has been enabled and you have rebooted, create either an external or internal switch. An external switch is preferred, but an internal switch can be used.
+
+## Download and Extract the Latest Release
+
+If you haven't [downloaded the latest release yet, do so](https://github.com/rbalsleyMSFT/FFU/releases)
+
+Once downloaded, open the zip file and copy the content of the FFUDevelopment folder to `C:\FFUDevelopment`. You can use another location, just be sure set your FFUDevelopmentPath to the new location (e.g. `D:\FFUDevelopment`).
+
+After extraction, you most likely will need to unblock the files as they'll be tagged with the mark of the web. In PowerShell run:
+
+`dir "C:\FFUDevelopment" -Recurse | Unblock-File`
+
+Replace `C:\FFUDevelopment` with the path you extracted the files to.
+
+## Running BuildFFUVM_UI.ps1
+
+Either run Terminal as Admin, making sure to select PowerShell, not Windows PowerShell, or PowerShell 7.5+ as Admin and run `C:\FFUDevelopment\BuildFFUVM_UI.ps1`
+
+If all went well, you should see the FFU Builder UI
+
+![1759527337644](image/Prerequisites/1759527337644.png)
+
+{% include page_nav.html %}

docs/quickstart.md

@@ -0,0 +1,288 @@
+---
+title: Quick Start
+nav_order: 2
+prev_url: /prerequisites.html
+prev_label: Prerequisites
+next_url: /ui_overview.html
+next_label: UI Overview
+---
+# Quick Start
+
+This is the quick start guide to getting started with FFU Builder. If you're new, start here to build your first FFU.
+
+After following this guide, you will have a USB drive with an FFU that contains the following:
+
+* Windows 11 25H2 (with your choice of architecture, language, SKU, and media type)
+* The latest
+  * Windows and .NET Cumulative Updates
+  * Defender definitions, platform updates, and Windows Security Center application update
+  * Microsoft Edge
+  * Microsoft OneDrive
+  * Malicious Software Removal Tool (MSRT)
+  * Microsoft 365 Apps (Current Channel)
+* Winget Applications (Optional)
+  * Company Portal
+* Drivers (Optional)
+  * In some cases drivers aren't necessary and you can get away with Windows Update providing drivers. We'll go over how to add drivers via the UI for Microsoft, HP, Lenovo, or Dell devices
+
+## Video Walkthrough
+
+<div style="position:relative;padding-bottom:56.25%;height:0;overflow:hidden;">
+  <iframe
+    src="https://www.youtube-nocookie.com/embed/kOIK5OmDugc"
+    title="YouTube video player"
+    style="position:absolute;top:0;left:0;width:100%;height:100%;border:0;"
+    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+    allowfullscreen>
+  </iframe>
+</div>
+
+## Prerequisites
+
+Follow the [prerequisites](/FFU/prerequisites.html) documentation before getting started.
+
+## Hyper-V Settings
+
+Click the Hyper-V Settings tab
+
+You should be able to keep these settings at the defaults. For VM Switch Name and VM Host IP Address, you'll want to make sure the switch you created in the prerequisites section is listed. FFU Builder should automatically figure out the IP address of the swtich for you.
+
+One setting you might need to set is the Logical Sector Size. 512 is the default and that's what most physical disks use today. However 4kn drives and UFS drives use 4k sector sizes, which would require you to select 4096. For now, select 512. If you have issues during deployment, there is error logging that will tell you if you need to set to 4096 on your device.
+
+## Windows Settings
+
+Click the Windows Settings tab
+
+If you keep ISO Path blank, FFU Builder will download the ESD file that the Windows Media Creation Tool uses. Most people should leave this blank since the Media Creation Tool media ESD file is now kept up to date as of Windows 11 25H2 (it's usually updated 2-3 days after patch Tuesday). This reduces the need to service the media and saves time and disk space.
+
+Change the Windows language to the one of your choosing.
+
+Change the Windows SKU to either Home or Pro depending on what your physical device(s) shipped with. This is due to how activation works by Windows. If you match the media type and SKU with what the device shipped with, then Windows will activate using the key in the firmware. In most scenarios, selecting Pro and Consumer will be what you want.
+
+Leave the other settings as is. There should be no need to provide a product key unless you're providing your own Windows ISO.
+
+## Updates
+
+Keep the defaults
+
+## Applications (optional)
+
+Click the Applications tab
+
+In this quick start we'll be installing the winget published version of the Company Portal application. This is optional, but it's a common application that IT admins like to install that use Intune to manage their devices. If you want to use something else, feel free to replace Company Portal with another app.
+
+You can also provide your own applications instead of, or in conjunction with, winget applications, however this guide will keep things simple and opt for using winget.
+
+Check Install Winget Applications
+
+Click Check Winget Status
+
+In the Winget Search box search for Company Portal
+
+If you see multiple applications, select the msstore source version of the Company Portal application (FFU Builder doesn't allow the winget source application to install due to how the application is packaged). Make sure to click the check box.
+
+Click the Save AppList.json button
+
+This will save an AppList.json file in your C:\FFUDevelopment\Apps folder and should look like this:
+
+```json
+{
+  "apps": [
+    {
+      "name": "Company Portal",
+      "id": "9WZDNCRFJ3PZ",
+      "source": "msstore",
+      "architecture": "NA",
+      "AdditionalExitCodes": "",
+      "IgnoreNonZeroExitCodes": false
+    }
+  ]
+}
+```
+
+{: .note-title}
+
+> Note
+>
+> The AppList.json file is what controls winget application downloads during the FFU build process. You might also notice that you can download the application by clicking the Download Selected button. That will do a point in time download of the selected applications via winget and will also update the AppList.json file. At build time the BuildFFUVM.ps1 script will check the AppList.json file and will check if the apps exist. If they do, it will skip downloading the applications.
+
+{: .note-title}
+
+> Note
+>
+> If your build machine isn't joined to Microsoft Entra, it will prompt you to authenticate twice to download any msstore source application. First for the application, and the second for the license file. This happens for each msstore source application. If this becomes annoying, you can run the FFUBuilder UI on an Entra joined machine (or hybrid joined) and download the apps you need and copy the Apps folder into the Apps folder on your build machine.
+
+{: .tip-title}
+
+> Tip
+>
+> To download winget applications with the msstore source, [you need one of the following rights on your account: Global Administrator, User Administrator, or License Administrator](https://learn.microsoft.com/en-us/windows/package-manager/winget/download#:~:text=The%20EntraID%20account%20used%20for%20authentication%20to%20generate%20and%20retrieve%20a%20Microsoft%20Store%20packaged%20app%20license%20file%20must%20be%20a%20member%20of%20one%20of%20the%20following%20three%20Azure%20roles%3A%20Global%20Administrator%2C%20User%20Administrator%2C%20or%20License%20Administrator.)
+
+## M365 Apps/Office
+
+FFU Builder uses the Office Deployment Tool to download and install Microsoft 365 Apps.
+
+The default configuration will install the 64-bit current channel version of Office with Word, Excel, Powerpoint. It will download the currently installed language of the operating system (i.e. uses MatchOS for language), which is fine for most people, however if you need to specify the correct language, you'll need to make some modifications to the XML files.
+
+Check the [M365 Apps/Office UI Overview page](/FFU/M365appsoffice.html) that explains the XMLs used in detail.
+
+## Drivers
+
+FFU Builder makes it easy to add drivers from the four major OEMs (Dell, HP, Lenovo, Microsoft). The difference between FFU Builder and other solutions is that FFU Builder tries to use the latest drivers from the OEM, not out-dated driver packages/CABs. This makes things somewhat more complicated to develop, but should make for a better experience where you have the most secure, up to date set of drivers available. It won't handle firmware/BIOS updates as Windows doesn't allow for servicing those types of updates.
+
+**Bring Your Own Drivers**
+
+You're also free to bring your own drivers instead of relying on using the drivers provided by FFU Builder. If you prefer the OEM cabs, you can download them and copy them to the `C:\FFUDevelopment\Drivers\<Make>\<Model>` folder where make is the name of the OEM and Model is the name of the model.
+
+**WinPE Drivers**
+
+FFU Builder also supports adding PE drivers. You can either copy your PE Drivers to the `C:\FFUDevelopment\PEDrivers` folder, or use the Drivers Folder as the PE drivers source. If you use the Drivers folder as the PE drivers source, the build script will find the appropriate driver class GUIDs for WinPE from the `C:\FFUDevelopment\Drivers` folder and copy them into the `C:\FFUDevelopment\PEDrivers` folder, overwriting what's currently in the PEDrivers folder.
+
+For the purposes of this quick start, we'll use an HP EliteBook 850 G8 as the example model.
+
+Click the Drivers tab and click the Download Drivers checkbox.
+
+In the Make drop down, select HP and click Get Models. This may take 10-30 seconds to download the HP PlatformList.cab file and parse it. Once the file has been downloaded and parsed, the model listview will be populated with all of the HP models. Dell has a similar experience with downloading and parsing its Catalog XML file. Microsoft parses some webpages to generate a SurfaceDriverIndex.json
+
+In the Model Filter text box, enter 850. This will filter down to all models that contain 850 in the model name. The model name column will list the model name and the system ID in parenthesis. The system ID is important because it's that value that is used at deployment time to automatically select which drivers to install if you've chosen to copy drivers to the USB drive instead of including them in the FFU file.
+
+Select **HP EliteBook 850 G8 Notebook PC (8846)**
+
+{: .tip-title}
+
+> Tip
+>
+> If you need to manage multiple models, it's best to select **Copy Drivers to USB drive.** This will keep the FFU file small and allow FFU Builder to automatically select the right drivers at deployment time (based on the system information queried via WMI).
+>
+> If you select Install Drivers to FFU, you bloat the driver store with drivers you don't need, creating a larger FFU file and wasting disk space on the physical device. It's best to use this option when building an FFU for a single model.
+
+To find the SystemID for HP, you can check BIOS/UEFI, or you can use PowerShell:
+
+```powershell
+(Get-CimInstance -Namespace 'root\WMI' -Class MS_SystemInformation).BaseboardProduct
+```
+
+Check **Copy Drivers to USB drive** (even though we're doing a single model in this quick start, most people will likely be managing many different models. The expectation is that most should be using **Copy Drivers to USB drive** in their workflows)
+
+Your view should look like this:
+
+![Drivers tab UI with HP 850 G8 selected and Copy Drivers to USB drive selected](image/quickstart/1769212208722.png "Drivers tab UI")
+
+At this point, you can either Save the Drivers.json file or click Download Selected. Clicking Save Drivers.json will save the Driver model information to the Drivers.json file which will be used at build time to download the drivers. Clicking Download Selected will download the drivers right now. This can be useful for testing without having to go through an entire build, or good for airgapped environments where you can download what you need from the internet on one network, and bring that over to the airgapped network.
+
+For this quick start, click **Save Drivers.json** and save the file to the `C:\FFUDevelopment\Drivers` folder.
+
+## Build
+
+Click the Build tab
+
+On the Build tab, click **Build USB Drive.**
+
+Depending on your USB drive, it might be a removable drive or external hard disk media. If you're using a fast USB SSD, it's likely that Windows treats that drive as an external hard disk. If that's the case, you might need to click **Allow External Hard Disk Media.** If you do, you may also want to uncheck **Prompt for External Hard Disk Media.** This option is in place to prevent external hard disks from automatically being formatted when building the USB drive. If you don't have any external hard disks connected to your build machine, then it's safe to uncheck the **Prompt for External Hard Disk Media** option.
+
+Another safety measure is **Select Specific USB Drives**. When you check **Select Specific USB Drives** a list view will pop up with a **Check USB drives** button. Clicking the **Check USB Drives** button will show all connected USB drives (removable or external hard disks). Select which drives you want.
+
+**Device Naming**
+
+Device naming can be done from PE. The way this works is by leveraging an unattend.xml file to either take input from the user at imaging time or read a list of prefix values and append the serial number of the device. There are some major benefits to doing this:
+
+1. Total deployment time is reduced if naming is set at FFU deployment time since there is no additional reboot done during OOBE.
+2. Reduces the need for multiple provisioning packages or autopilot profiles. This means you can use a single PPKG or autopilot profile.
+
+**Prompt for Device Name**
+
+If you want to be prompted for the device name, simply check **Copy Unattend.xml.** This tells the build script to copy the appropriate architecture unattend_arch.xml file from the `C:\FFUDevelopment\Unattend` folder to the `.\unattend` folder on the deploy partition of the USB drive.
+
+**Specifying Multiple Name Prefixes**
+
+If you have multiple device name prefixes for different locations or device use cases, or even a single prefix, you can specify a prefixes.txt file in the `C:\FFUDevelopment\unattend` folder. If the prefixes.txt file is detected and a single prefix is listed, the device will just use that prefix and append the serial number of the device. If there are multiple prefixes listed in the prefixes.txt file, you will be prompted to select which prefix you want to name the device and the serial number will be appended to that prefix. If you want a dash in the name, include the dash in the prefix (e.g. if ABCD- is in the prefixes.txt file, the device name will be ABCD-SerialNumber).
+
+{: .warning-title}
+
+> Warning
+>
+> If using a provisioning package or autopilot json file, DO NOT specify a name in either of these. They will overwrite the name you have specified in the unattend.xml.
+
+**Post Build Cleanup**
+
+Leave the Post Build Cleanup section at the defaults
+
+Your Build tab should look something like this:
+
+![1769218100003](image/quickstart/1769218100003.png)
+
+Click **Build FFU**
+
+Depending on your internet speed, speed of your build machine, etc. this will take some time (probably at least 20 minutes). After clicking Build FFU, you'll be automatically moved to the Monitor tab.
+
+## Monitor
+
+![1769218278316](image/quickstart/1769218278316.png)
+
+The monitor tab parses the `C:\FFUDevelopment\FFUDevelopment.log` file. If you'd like to use CMTrace or another tool to monitor the log, feel free. The monitor tab has some similar functionality to CMTrace. If you click off the last line of the log in the monitor tab it will stay on that line, allowing you to read what you have selected instead of the log autoscrolling. You can also copy one or multiple lines by selecting a line and shift+clicking the last line you want to select and hitting ctrl+c to copy the lines.
+
+Now sit back, relax, and watch FFU Builder do its magic. You should see a VM pop up after everything is downloaded and Windows has been installed to the VHDX file (it may not if Hyper-V manager wasn't previously open). If you don't see a VM pop up, you can open up Hyper-V manager and look for a VM with a name that starts with **_FFU-.**
+
+{: .note-title}
+
+> Note
+>
+> Don't interact with the VM (e.g. don't click into the PowerShell window that's orchestrating the install of the updates, apps, etc). The whole process should be completly automated with no user interaction necessary. If you click into the PowerShell window while it's working, you may get PowerShell into "select" mode. If this happens, the PowerShell window will look like it's "stuck." That's because clicking into a cmd/PowerShell window while something is in process and you're in select mode waits for you to exit select by hitting Enter. 
+
+## Post Build
+
+Once the build is complete, you should have a USB drive with two partitions: Boot and Deploy.
+
+The Boot partition is the WinPE Deployment media. It'll look like this:
+
+![1769222221857](image/quickstart/1769222221857.png)
+
+The Deploy partition is where the FFU file, the Drivers folder, and Unattend folders should be.
+
+![1769222271610](image/quickstart/1769222271610.png)
+
+The Drivers folder will have an HP folder, a DriverMapping.json and Drivers.json file.
+
+![1769222319233](image/quickstart/1769222319233.png)
+
+The DriverMapping.json file is what's used to do automatic driver matching during deployment. FFU Builder will read this file and match on the SystemID to know which driver folder to apply. Since there's only a single driver folder in this example, the file is fairly simple to understand. When you have multiple models and OEMs, the file gets a bit more complex.
+
+The DriverMapping.json should look like this:
+
+```json
+{
+  "Manufacturer": "HP",
+  "Model": "HP EliteBook 850 G8 Notebook PC (8846)",
+  "DriverPath": "HP\\HP EliteBook 850 G8 Notebook PC (8846)",
+  "SystemId": "8846"
+}
+```
+
+The HP EliteBook 850 driver folder should be populated with the various driver categories:
+
+![1769222537720](image/quickstart/1769222537720.png)
+
+And the Unattend folder should have an unattend.xml file with the following content:
+
+```xml
+<?xml version="1.0" encoding="utf-8"?>
+<unattend xmlns="urn:schemas-microsoft-com:unattend">
+  <settings pass="specialize">
+  <!--<ComputerName> must be in the first Component Element  "Microsoft-Windows-Shell-Setup" . Do not change the order or remove it -->
+    <component name="Microsoft-Windows-Shell-Setup" processorArchitecture="amd64" publicKeyToken="31bf3856ad364e35" language="neutral" versionScope="nonSxS" xmlns:wcm="http://schemas.microsoft.com/WMIConfig/2002/State" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+      <ComputerName>MyComputer</ComputerName>
+    </component>
+  <!--Place addtional Components Elements and settings below here. -->
+  </settings>
+</unattend>
+```
+
+Now you're ready to deploy the FFU to your device. 
+
+## Deployment
+
+Deployment should be fairly straight forward: boot off the USB device, get prompted for a device name, and the deployment of the FFU and drivers should happen automatically. 
+
+If you have any questions or run into any issues, [open a discussion in the Github repo](https://github.com/rbalsleyMSFT/FFU/discussions).
+
+{% include page_nav.html %}

docs/reference.md

@@ -0,0 +1,19 @@
+---
+title: Reference
+nav_order: 5
+prev_url: /helper_scripts.html
+prev_label: Helper Scripts
+next_url: /parameters_reference.html
+next_label: Parameters Reference
+has_children: true
+has_toc: false
+---
+# Reference
+
+This section contains deep-dive documentation that explains how FFU Builder works behind the UI.
+
+## Available reference guides
+
+- [BuildFFUVM Parameter Reference](/FFU/parameters_reference.html)
+
+{% include page_nav.html %}

docs/robots.txt

@@ -0,0 +1,4 @@
+User-agent: *
+Allow: /
+
+Sitemap: https://rbalsleymsft.github.io/FFU/sitemap.xml

docs/sitemap.xml

@@ -0,0 +1,17 @@
+---
+layout: null
+---
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+{% assign sortedPages = site.pages | sort: "url" %}
+{% for page in sortedPages %}
+{% if page.sitemap != false and page.url != "/404.html" %}
+{% if page.url == "/" or page.url contains ".html" %}
+  <url>
+    <loc>{{ site.url }}{{ site.baseurl }}{{ page.url | replace: "index.html", "" }}</loc>
+    <lastmod>{{ site.time | date_to_xmlschema }}</lastmod>
+  </url>
+{% endif %}
+{% endif %}
+{% endfor %}
+</urlset>

docs/ui_overview.md

@@ -0,0 +1,14 @@
+---
+title: UI Overview
+nav_order: 3
+prev_url: /prerequisites.html
+prev_label: Prerequisites
+next_url: /hyperv_settings.html
+next_label: Hyper-V Settings
+has_toc: false
+---
+# UI Overview
+
+![1759527337644](image/Prerequisites/1759527337644.png)
+
+The user interface has 9 distinct tabs for easy navigation.

docs/updates.md

@@ -0,0 +1,52 @@
+---
+title: Updates
+nav_order: 3
+prev_url: /windows_settings.html
+prev_label: Windows Settings
+next_url: /applications.html
+next_label: Applications
+parent: UI Overview
+---
+# Updates
+
+![1759878277807](image/updates/1759878277807.png)
+
+## Update Latest Cumulative Update
+
+Controls the `-UpdateLatestCU` parameter. When set to `$true`, will download and install the latest cumulative update for Windows.
+
+## Update .NET
+
+Controls the `-UpdateLatestNet` parameter. When set to `$true`, will download and install the latest .NET framework update for Windows.
+
+## Update Defender
+
+Controls the `-UpdateLatestDefender` parameter. When set to `$true`, will download and install the latest Windows Defender definitions, Defender platform, and Windows Security app update.
+
+## Update Edge
+
+Controls the `-UpdateEdge` parameter. When set to `$true`, will download and install the latest Microsoft Edge browser.
+
+## Update OneDrive (per-machine)
+
+Controls the `-UpdateOneDrive` parameter. When set to `$true`, will download and install the latest OneDrive and install it as per-machine instead of per-user.
+
+## Update Microsoft Software Removal Tool (MSRT)
+
+Controls the `-UpdateLatestMSRT` parameter. When set to `$true`, will download and install the latest Windows Malicious Software Removal Tool.
+
+## Update Latest Microcode (for LTSC/Server 2016/2019)
+
+Controls the `-UpdateLatestMicrocode` parameter. When set to `$true`, will download and install the latest microcode updates for applicable Windows releases (e.g., Windows Server 2016/2019, Windows 10 LTSC 2016/2019) into the FFU.
+
+## Update Preview Cumulative Update
+
+Controls the `-UpdatePreviewCU` parameter. When set to `$true`, will download and install the latest preview cumulative update for Windows.
+
+{: .note-title}
+
+> Note
+>
+> The UI will only allow one of **Update Latest CU** or **Update Preview CU** to be checked to prevent both being applied. 
+
+{% include page_nav.html %}

docs/usb_imaging_tool_creator.md

@@ -0,0 +1,76 @@
+---
+title: USB Imaging Tool Creator
+nav_order: 2
+prev_url: /create_pemedia.html
+prev_label: Create PE Media
+parent: Helper Scripts
+---
+# USB Imaging Tool Creator
+
+`USBImagingToolCreator.ps1` is a standalone helper for creating one or more deployment USB drives from a deploy ISO, FFU files, and optional drivers. This is best used when you want to provide remote technicians the FFU file(s) you've built and optionally a drivers folder that contains the drivers for the models they will need to manage. They can also provide their own drivers (using Drivers\Make\Model format (e.g Drivers\Dell\Optiplex 7060 (085D))
+
+## How the script works
+
+- `-DeployISOPath` is required and should point to the deploy ISO file.
+- The script uses the parent folder of that ISO as its working root.
+- FFU files are copied from `<ISO parent>\FFU` (all `.ffu` files, recursive).
+- Drivers are copied from `<ISO parent>\Drivers` (recursive) when present.
+- If drivers are not found, the script creates an empty `Drivers` folder on each deploy partition.
+- `-DisableAutoPlay` is optional and temporarily disables AutoPlay for the current user during media creation. This is useful in situations where you see File Explorer pop ups as it's building the USB drive.
+
+## Network share workflow (admin/technician)
+
+For a shared workflow, stage one folder on a share with the deploy ISO and content that technicians should copy to USB drives.
+
+If you do not already have a deployment ISO in the staging location, create one first using [Create PE Media](/FFU/create_pemedia.html). This lets admins quickly generate the deploy ISO and then stage it for technicians using `USBImagingToolCreator.ps1`.
+
+Example layout:
+
+```text
+\\Server\FFUStaging\
+  WinPE_FFU_Deploy.iso
+  FFU\
+    <image files>.ffu
+  Drivers\
+    <optional driver content>
+```
+
+Run from an elevated PowerShell session:
+
+```powershell
+.\USBImagingToolCreator.ps1 -DeployISOPath "\\Server\FFUStaging\WinPE_FFU_Deploy.iso" -DisableAutoPlay
+```
+
+The script passes `-DeployISOPath` directly to `Mount-DiskImage`, so use a path the local Windows host can mount.
+
+## Example folder structure
+
+In this example a folder named USBCreator was made and the Drivers and FFU folders as well as the WinPE_FFU_Deploy_x64.iso and USBImagingToolCreator.ps1 files were copied from the FFUDevelopment folder to this new folder.
+
+![1771882385742](image/usb_imaging_tool_creator/1771882385742.png)
+
+## What happens when you run it
+
+1. Detects disks with media type **Removable media** or **External hard disk media**.
+2. Prompts for a single drive selection or an all-drives selection.
+3. Stops `mmc` and `diskpart` processes to reduce drive lock issues.
+4. Erases each selected disk and rebuilds it as MBR with:
+   - `Boot` partition (2 GB, FAT32, active)
+   - `Deploy` partition (remaining space, NTFS)
+5. Mounts the deploy ISO and copies all ISO content to every `Boot` partition.
+6. Copies FFU content to every `Deploy` partition.
+7. Copies driver content into `Deploy\Drivers` (or creates an empty `Drivers` folder).
+8. Dismounts the ISO and reports completion.
+
+{: .warning-title}
+
+> Warning
+>
+> Selected disks are fully erased (`Clear-Disk -RemoveData -RemoveOEM`), so verify drive selection carefully, especially when using the all-drives option.
+
+## Logging and progress
+
+- Progress is shown in the PowerShell progress UI.
+- `Script.log` is written in the same folder as the deploy ISO (the working root folder).
+
+{% include page_nav.html %}

docs/windows_settings.md

@@ -0,0 +1,147 @@
+---
+title: Windows Settings
+nav_order: 2
+prev_url: /hyperv_settings.html
+prev_label: Hyper-V Settings
+next_url: /updates.html
+next_label: Updates
+parent: UI Overview
+---
+# Windows Settings
+
+![1759535556990](image/ui_overview/1759535556990.png)
+
+## Windows ISO Path
+
+Path to Windows 10/11 ISO file. If left blank, FFU Builder will download the latest version of Windows 10 or 11 from the Media Creation Tool.
+
+{: .tip-title}
+
+> Tip
+>
+> Should I provide my own ISO, or let FFU Builder download the media
+>
+> It's recommended to use the latest updated ISO from Visual Studio Downloads, or the Media Creation tool. See the Media Type section below for a better understanding of business and consumer media and how it impacts Subscription Activation.
+
+## Windows Release
+
+Integer value of 10 or 11. This is used to identify which release of Windows to download. Default is 11.
+
+## Windows Version
+
+String value of the Windows version. Default is `25H2`. If an ISO is not specified, this drop down is disabled. If an ISO is specified, you can select from the drop down which version of Windows you're installing. The Windows version is used in quite a few different scenarios (HP driver downloads, VHDXCaching, MCT media downloads, FFU file naming, and cumulative update downloads), so it's important you specify the correct Windows Version.
+
+## Windows Architecture
+
+String value of `x86`, `x64`, or `arm64`. Depending on the Windows release and Windows version, the UI will only specify the supported architecture types for a specific Release/Version combo.
+
+## Windows Language
+
+String value in language-region format (e.g., `en-us`). This is used to identify which language of media to download. Default is `en-us`.
+
+{: .note-title}
+
+> Note
+>
+> These are the supported languages that can be used with the `-WindowsLang` parameter when downloading the Windows MCT\ESD file
+>
+> ar-sa
+> bg-bg
+> cs-cz
+> da-dk
+> de-de
+> el-gr
+> en-gb
+> en-us
+> es-es
+> es-mx
+> et-ee
+> fi-fi
+> fr-ca
+> fr-fr
+> he-il
+> hr-hr
+> hu-hu
+> it-it
+> ja-jp
+> ko-kr
+> lt-lt
+> lv-lv
+> nb-no
+> nl-nl
+> pl-pl
+> pt-br
+> pt-pt
+> ro-ro
+> ru-ru
+> sk-sk
+> sl-si
+> sr-latn-rs
+> sv-se
+> th-th
+> tr-tr
+> uk-ua
+> zh-cn
+> zh-tw
+
+## Windows SKU
+
+Edition of Windows 10/11/LTSC/Server to be installed.
+
+{: .note-title}
+
+> Note
+>
+> The following SKUs are supported
+>
+> Home
+> Home N
+> Home Single Language
+> Education
+> Education N
+> Pro
+> Pro N
+> Pro Education
+> Pro Education N
+> Pro for Workstations
+> Pro N for Workstations
+> Enterprise
+> Enterprise N
+> Enterprise 2016 LTSB
+> Enterprise N 2016 LTSB
+> Enterprise LTSC
+> Enterprise N LTSC
+> IoT Enterprise LTSC
+> IoT Enterprise N LTSC
+> Standard
+> Standard (Desktop Experience)
+> Datacenter
+> Datacenter (Desktop Experience)
+
+## Media Type
+
+String value of either `business` or `consumer`. This is used to identify which media type to download if not providing an ISO. Default is `consumer`
+
+{: .tip-title}
+
+> Tip
+>
+> Recommendation on media type to use
+>
+> Windows media comes in two types: business or consumer.
+>
+> Windows media can be obtained from a few different sources: Volume Licensing Service Center (VLSC – now available at admin.microsoft.com), Microsoft Visual Studio Downloads, or the Windows Media Creation Tool.
+>
+> The `BuildFFUVM.ps1` script will allow you to pass whichever type of media you want from whatever source you want using the -ISOPath parameter; however, **it’s recommended that you use consumer media**, not business/VL. This is because Subscription Activation will fail if the media is mismatched from the key in the firmware.
+>
+> If you plan on using a MAK or KMS to activate, you can use media from VLSC, but if you expect the device to activate automatically and upgrade to Enterprise or Education SKUs via Subscription Activation, you must use consumer media. To use a MAK/KMS key to activate, you must provide the -`ProductKey XXXXX-XXXXX-XXXXX-XXXXX-XXXXX` parameter.
+
+## Product Key
+
+Product key for the Windows edition specified in WindowsSKU. This will overwrite whatever SKU is entered for WindowsSKU. Recommended to use if you want to use a MAK or KMS key to activate Enterprise or Education. If using VL media instead of consumer media, you'll want to enter a MAK or KMS key here.
+
+## Optional Features
+
+A list of optional features that you can enable for the version of Windows you're installing (e.g. netfx3; TFTP). 
+
+{% include page_nav.html %}

docs/winget.md

@@ -0,0 +1,118 @@
+---
+title: Install Winget Applications
+nav_order: 5
+prev_url: /applications.html
+prev_label: Applications
+next_url: /byoapps.html
+next_label: BYO Applications
+parent: Applications
+grand_parent: UI Overview
+---
+# Install Winget Applications
+
+![FFU Builder UI - Applications tab with Install Winget Applications checked searching for windows app](image/applicationscopy/1759882085098.png "FFU Builder UI - Applications tab with Install Winget Applications checked searching for windows app")
+
+## Check Winget Status
+
+Installing Winget applications requires that both the winget CLI and Microsoft.Winget.Client PowerShell module to be installed. Minimum required version of both the CLI and PowerShell module is 1.8.1911.
+
+Click **Check Winget Status** to validate the versions of both the CLI and PowerShell module. If older than the minimum required version, will be updated to the latest version.
+
+![Check Winget Status button](image/winget/1759883187930.png "Check Winget Status button")
+
+After validating Winget status, you'll be able to search winget for applications. The larger the result set, the longer it will take for the list view to be populated. For example, if searching for **win**, the UI might appear to hang while it searches for apps with a name or id of **win** due to 669 results being returned and processed. Instead, if you search for **windows app**, 13 results are returned within a few seconds.
+
+The UI allows for multi-selection of applications
+
+![Winget search list view with Windows App, VLC media player, and Snagit 2025 selected](image/winget/1759884200465.png "Winget search list view with Windows App, VLC media player, and Snagit 2025 selected")
+
+You can also change the architecture, add additional exit codes, or ignore exit codes completely.
+
+## Architecture
+
+![Architecture options that can be selected for winget applications](image/winget/1759884446099.png "Architecture options that can be selected for winget applications")
+
+FFU Builder supports x86, x64, arm64, and x86/x64 (both) for applications in the winget source repository. For apps in the msstore source repository, the architecture cannot be changed. In most cases, x64 will be what you want, however in some cases the combo of x86 and x64 will be necessary. This might be due to runtimes (.NET, Visual C++) where an application is expecting both x86 and x64 runtimes.
+
+## Additional Exit Codes
+
+You can provide a comma separated list of additional exit codes if your application doesn't exit with 0. Some apps may exit with a non-zero exit code.
+
+## Ignore Exit Codes
+
+If you know your application exits with some random exit code or simply don't care to populate a list of approved exit codes, check the box to ignore exit codes and FFU Builder will ignore the exit code and continue on.
+
+## Download Status
+
+FFU Builder allows you to download applications prior to deployment. When clicking the Download Selected button, the Download Status column tracks the status of the download and outputs success, or in the case of an error, the reason why the download may have failed.
+
+## Save AppList.json
+
+FFU Builder leverages a number of json files to tell the `BuildFFUVM.ps1` script what to do during deployment time. `AppList.json` controls the Winget application download and installation.
+
+The `AppList.json` file gets created when clicking **Download Selected**, or clicking the **Save AppList.json** file. The default path for the `AppList.json` file is `$AppsPath\AppList.json`
+
+An example of the `AppList.json` file:
+
+```json
+{
+  "apps": [
+    {
+      "name": "Windows App",
+      "id": "Microsoft.WindowsApp",
+      "source": "winget",
+      "architecture": "x64",
+      "AdditionalExitCodes": "",
+      "IgnoreNonZeroExitCodes": false
+    },
+    {
+      "name": "VLC media player",
+      "id": "VideoLAN.VLC",
+      "source": "winget",
+      "architecture": "x64",
+      "AdditionalExitCodes": "",
+      "IgnoreNonZeroExitCodes": false
+    },
+    {
+      "name": "Snagit 2025",
+      "id": "TechSmith.Snagit.2025",
+      "source": "winget",
+      "architecture": "x64",
+      "AdditionalExitCodes": "",
+      "IgnoreNonZeroExitCodes": false
+    },
+    {
+      "name": "Company Portal",
+      "id": "9WZDNCRFJ3PZ",
+      "source": "msstore",
+      "architecture": "NA",
+      "AdditionalExitCodes": "",
+      "IgnoreNonZeroExitCodes": false
+    }
+  ]
+}
+```
+
+## Import AppList.json
+
+If you have a previously saved `AppList.json` you want to use or modify, you can import an `AppList.json` file.
+
+## Download Selected
+
+As mentioned in the Download Selected section above, FFU Builder allows you to download applications prior to deployment. When clicking the Download Selected button, the Download Status column tracks the status of the download and outputs success, or in the case of an error, the reason why the download may have failed. By default it will download five applications at a time. This is controlled by the
+
+Apps are downloaded to `.\FFUDevelopment\Apps\Win32\<AppName>` or `.\FFUDevelopment\Apps\MSStore\<AppName>` depending on the winget source value. Each application will have the app installation files and a yaml manifest file. For Win32 applications, FFU Builder parses the yaml file to grab the silent install switches needed for silent application installation at build time.
+
+{: .tip-title}
+
+> Tip
+>
+> When downloading msstore source applications, Microsoft requires applications to be downloaded with a license file (the Winget PowerShell module doesn't allow the option to skip downloading the license like the winget CLI does). This requires authentication via Entra ID. If using a device joined to Entra and signed in with your Entra ID, SSO will bypass the need to re-authenticate to download the app and license file. If the machine you are running FFU Builder on is not joined to Entra ID, you will be prompted twice to download the application and the license file.
+>
+> It's recommended that if you are downloading a lot of msstore source applications, do it from a machine that's joined to Entra ID.
+
+## Clear List
+
+The Clear List button will clear the list view of what's currently in it. It will not clear the AppList.json file if it exists.
+
+{% include page_nav.html %}