56 files changed, 1508 insertions, 1676 deletions

diff --git a/src/api/wix/WixToolset.Data/ErrorMessages.cs b/src/api/wix/WixToolset.Data/ErrorMessages.cs
index 40378a2e..77ce73aa 100644
--- a/src/api/wix/WixToolset.Data/ErrorMessages.cs
+++ b/src/api/wix/WixToolset.Data/ErrorMessages.cs
@@ -651,7 +651,8 @@ namespace WixToolset.Data
         public static Message FileNotFound(SourceLineNumber sourceLineNumbers, string file, string fileType, IEnumerable<string> checkedPaths)
         {
             var combinedCheckedPaths = String.Join(", ", checkedPaths);
-            return Message(sourceLineNumbers, Ids.FileNotFound, "The system cannot find the file '{0}' with type '{1}'. The following paths were checked: {2}", file, fileType, combinedCheckedPaths);
+            var withType = String.IsNullOrEmpty(fileType) ? String.Empty : $" with type '{fileType}'";
+            return Message(sourceLineNumbers, Ids.FileNotFound, "The system cannot find the file '{0}'{1}. The following paths were checked: {2}", file, withType, combinedCheckedPaths);
         }
 
         public static Message FileOrDirectoryPathRequired(string parameter)
diff --git a/src/api/wix/WixToolset.Data/Symbols/WixPatchBaselineSymbol.cs b/src/api/wix/WixToolset.Data/Symbols/WixPatchBaselineSymbol.cs
index d7295424..cbf51e2e 100644
--- a/src/api/wix/WixToolset.Data/Symbols/WixPatchBaselineSymbol.cs
+++ b/src/api/wix/WixToolset.Data/Symbols/WixPatchBaselineSymbol.cs
@@ -14,7 +14,6 @@ namespace WixToolset.Data
                 new IntermediateFieldDefinition(nameof(WixPatchBaselineSymbolFields.ValidationFlags), IntermediateFieldType.Number),
                 new IntermediateFieldDefinition(nameof(WixPatchBaselineSymbolFields.BaselineFile), IntermediateFieldType.Path),
                 new IntermediateFieldDefinition(nameof(WixPatchBaselineSymbolFields.UpdateFile), IntermediateFieldType.Path),
-                new IntermediateFieldDefinition(nameof(WixPatchBaselineSymbolFields.TransformFile), IntermediateFieldType.Path),
             },
             typeof(WixPatchBaselineSymbol));
     }
@@ -28,7 +27,6 @@ namespace WixToolset.Data.Symbols
         ValidationFlags,
         BaselineFile,
         UpdateFile,
-        TransformFile,
     }
 
     public class WixPatchBaselineSymbol : IntermediateSymbol
@@ -66,11 +64,5 @@ namespace WixToolset.Data.Symbols
             get => this.Fields[(int)WixPatchBaselineSymbolFields.UpdateFile].AsPath();
             set => this.Set((int)WixPatchBaselineSymbolFields.UpdateFile, value);
         }
-
-        public IntermediateFieldPathValue TransformFile
-        {
-            get => this.Fields[(int)WixPatchBaselineSymbolFields.TransformFile].AsPath();
-            set => this.Set((int)WixPatchBaselineSymbolFields.TransformFile, value);
-        }
     }
 }
diff --git a/src/api/wix/WixToolset.Extensibility/Data/IBindContext.cs b/src/api/wix/WixToolset.Extensibility/Data/IBindContext.cs
index 671da292..9d663c65 100644
--- a/src/api/wix/WixToolset.Extensibility/Data/IBindContext.cs
+++ b/src/api/wix/WixToolset.Extensibility/Data/IBindContext.cs
@@ -18,6 +18,11 @@ namespace WixToolset.Extensibility.Data
         IServiceProvider ServiceProvider { get; }
 
         /// <summary>
+        /// Bind paths used during resolution.
+        /// </summary>
+        IReadOnlyCollection<IBindPath> BindPaths { get; set; }
+
+        /// <summary>
         /// Counnt of threads to use in cabbing.
         /// </summary>
         int CabbingThreadCount { get; set; }
diff --git a/src/api/wix/WixToolset.Extensibility/Data/IFileFacade.cs b/src/api/wix/WixToolset.Extensibility/Data/IFileFacade.cs
index fea00d4e..8a9e3fee 100644
--- a/src/api/wix/WixToolset.Extensibility/Data/IFileFacade.cs
+++ b/src/api/wix/WixToolset.Extensibility/Data/IFileFacade.cs
@@ -5,34 +5,13 @@ namespace WixToolset.Extensibility.Data
     using System.Collections.Generic;
     using WixToolset.Data;
     using WixToolset.Data.Symbols;
-    using WixToolset.Data.WindowsInstaller.Rows;
 
     /// <summary>
-    /// Interface that provides a common facade over <c>FileSymbol</c> and <c>FileRow</c>.
+    /// Interface that provides a common facade over file information.
     /// </summary>
     public interface IFileFacade
     {
         /// <summary>
-        /// Reference to assembly application for this file.
-        /// </summary>
-        string AssemblyApplicationFileRef { get; }
-
-        /// <summary>
-        /// Reference to assembly manifest for this file.
-        /// </summary>
-        string AssemblyManifestFileRef { get; }
-
-        /// <summary>
-        /// List of assembly name values in the file.
-        /// </summary>
-        List<MsiAssemblyNameSymbol> AssemblyNames { get; set; }
-
-        /// <summary>
-        /// Optionally indicates what sort of assembly the file is.
-        /// </summary>
-        AssemblyType? AssemblyType { get; }
-
-        /// <summary>
         /// Component containing the file.
         /// </summary>
         string ComponentRef { get; }
@@ -58,21 +37,6 @@ namespace WixToolset.Extensibility.Data
         int FileSize { get; set; }
 
         /// <summary>
-        /// Indicates whether the file came from a merge module.
-        /// </summary>
-        bool FromModule { get; }
-
-        /// <summary>
-        /// Indicates whether the file came from a transform.
-        /// </summary>
-        bool FromTransform { get; }
-
-        /// <summary>
-        /// Hash symbol of the file.
-        /// </summary>
-        MsiFileHashSymbol Hash { get; set; }
-
-        /// <summary>
         /// Underlying identifier of the file.
         /// </summary>
         Identifier Identifier { get; }
@@ -118,9 +82,13 @@ namespace WixToolset.Extensibility.Data
         string Version { get; set; }
 
         /// <summary>
-        /// Gets the underlying <c>FileRow</c> if one is present.
+        /// Calculated hash of the file.
+        /// </summary>
+        MsiFileHashSymbol MsiFileHashSymbol { get; set; }
+
+        /// <summary>
+        /// Assembly names found in the file.
         /// </summary>
-        /// <returns><c>FileRow</c> if one is present, otherwise throws.</returns>
-        FileRow GetFileRow();
+        ICollection<MsiAssemblyNameSymbol> AssemblyNameSymbols { get; }
     }
 }
diff --git a/src/api/wix/WixToolset.Extensibility/Data/IWindowsInstallerDecompileContext.cs b/src/api/wix/WixToolset.Extensibility/Data/IWindowsInstallerDecompileContext.cs
index 27d30a5a..7b974942 100644
--- a/src/api/wix/WixToolset.Extensibility/Data/IWindowsInstallerDecompileContext.cs
+++ b/src/api/wix/WixToolset.Extensibility/Data/IWindowsInstallerDecompileContext.cs
@@ -63,11 +63,6 @@ namespace WixToolset.Extensibility.Data
         string IntermediateFolder { get; set; }
 
         /// <summary>
-        /// Gets or sets whether the decompiler admin image.
-        /// </summary>
-        bool IsAdminImage { get; set; }
-
-        /// <summary>
         /// Gets or sets where to output the result.
         /// </summary>
         string OutputPath { get; set; }
diff --git a/src/api/wix/WixToolset.Extensibility/Services/IBackendHelper.cs b/src/api/wix/WixToolset.Extensibility/Services/IBackendHelper.cs
index eff42b99..8bb1b2d6 100644
--- a/src/api/wix/WixToolset.Extensibility/Services/IBackendHelper.cs
+++ b/src/api/wix/WixToolset.Extensibility/Services/IBackendHelper.cs
@@ -5,8 +5,6 @@ namespace WixToolset.Extensibility.Services
     using System;
     using System.Collections.Generic;
     using WixToolset.Data;
-    using WixToolset.Data.Symbols;
-    using WixToolset.Data.WindowsInstaller.Rows;
     using WixToolset.Extensibility.Data;
 
     /// <summary>
@@ -15,28 +13,6 @@ namespace WixToolset.Extensibility.Services
     public interface IBackendHelper : ILayoutServices
     {
         /// <summary>
-        /// Creates a file facade from a <c>FileSymbol</c> and possible <c>AssemblySymbol</c>.
-        /// </summary>
-        /// <param name="file"><c>FileSymbol</c> backing the facade.</param>
-        /// <param name="assembly"><c>AssemblySymbol</c> backing the facade.</param>
-        /// <returns></returns>
-        IFileFacade CreateFileFacade(FileSymbol file, AssemblySymbol assembly);
-
-        /// <summary>
-        /// Creates a file facade from a File row.
-        /// </summary>
-        /// <param name="fileRow"><c>FileRow</c> </param>
-        /// <returns>New <c>IFileFacade</c>.</returns>
-        IFileFacade CreateFileFacade(FileRow fileRow);
-
-        /// <summary>
-        /// Creates a file facade from a Merge Module's File symbol.
-        /// </summary>
-        /// <param name="fileSymbol"><c>FileSymbol</c> created from a Merge Module.</param>
-        /// <returns>New <c>IFileFacade</c>.</returns>
-        IFileFacade CreateFileFacadeFromMergeModule(FileSymbol fileSymbol);
-
-        /// <summary>
         /// Creates a MSI compatible GUID.
         /// </summary>
         /// <returns>Creates an uppercase GUID with braces.</returns>
diff --git a/src/api/wix/WixToolset.Extensibility/Services/IFileResolver.cs b/src/api/wix/WixToolset.Extensibility/Services/IFileResolver.cs
new file mode 100644
index 00000000..2804cc28
--- /dev/null
+++ b/src/api/wix/WixToolset.Extensibility/Services/IFileResolver.cs
@@ -0,0 +1,38 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Extensibility.Services
+{
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Extensibility.Data;
+
+    /// <summary>
+    /// Interface to resolve file paths using extensions and bind paths.
+    /// </summary>
+    public interface IFileResolver
+    {
+        /// <summary>
+        /// Resolves the source path of a file using binder extensions.
+        /// </summary>
+        /// <param name="source">Original source value.</param>
+        /// <param name="librarianExtensions">Extensions used to resolve the file path.</param>
+        /// <param name="bindPaths">Collection of bind paths for the binding stage.</param>
+        /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param>
+        /// <param name="symbolDefinition">Optional type of source file being resolved.</param>
+        /// <returns>Should return a valid path for the stream to be imported.</returns>
+        string ResolveFile(string source, IEnumerable<ILibrarianExtension> librarianExtensions, IEnumerable<IBindPath> bindPaths, SourceLineNumber sourceLineNumbers, IntermediateSymbolDefinition symbolDefinition);
+
+        /// <summary>
+        /// Resolves the source path of a file using binder extensions.
+        /// </summary>
+        /// <param name="source">Original source value.</param>
+        /// <param name="resolverExtensions">Extensions used to resolve the file path.</param>
+        /// <param name="bindPaths">Collection of bind paths for the binding stage.</param>
+        /// <param name="bindStage">The binding stage used to determine what collection of bind paths will be used</param>
+        /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param>
+        /// <param name="symbolDefinition">Optional type of source file being resolved.</param>
+        /// <param name="alreadyCheckedPaths">Optional collection of paths already checked.</param>
+        /// <returns>Should return a valid path for the stream to be imported.</returns>
+        string ResolveFile(string source, IEnumerable<IResolverExtension> resolverExtensions, IEnumerable<IBindPath> bindPaths, BindStage bindStage, SourceLineNumber sourceLineNumbers, IntermediateSymbolDefinition symbolDefinition, IEnumerable<string> alreadyCheckedPaths = null);
+    }
+}
diff --git a/src/api/wix/WixToolset.Extensibility/Services/IWindowsInstallerBackendHelper.cs b/src/api/wix/WixToolset.Extensibility/Services/IWindowsInstallerBackendHelper.cs
index 81325131..2216e957 100644
--- a/src/api/wix/WixToolset.Extensibility/Services/IWindowsInstallerBackendHelper.cs
+++ b/src/api/wix/WixToolset.Extensibility/Services/IWindowsInstallerBackendHelper.cs
@@ -3,7 +3,10 @@
 namespace WixToolset.Extensibility.Services
 {
     using WixToolset.Data;
+    using WixToolset.Data.Symbols;
     using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Data.WindowsInstaller.Rows;
+    using WixToolset.Extensibility.Data;
 
     /// <summary>
     /// Interface provided to help Windows Installer backend extensions.
@@ -11,6 +14,20 @@ namespace WixToolset.Extensibility.Services
     public interface IWindowsInstallerBackendHelper : IBackendHelper
     {
         /// <summary>
+        /// Creates a file facade from a <c>FileSymbol</c>.
+        /// </summary>
+        /// <param name="file"><c>FileSymbol</c> backing the facade.</param>
+        /// <returns></returns>
+        IFileFacade CreateFileFacade(FileSymbol file);
+
+        /// <summary>
+        /// Creates a file facade from a File row.
+        /// </summary>
+        /// <param name="fileRow"><c>FileRow</c></param>
+        /// <returns>New <c>IFileFacade</c>.</returns>
+        IFileFacade CreateFileFacade(FileRow fileRow);
+
+        /// <summary>
         /// Creates a <see cref="Row"/> in the specified table.
         /// </summary>
         /// <param name="section">Parent section.</param>
diff --git a/src/wix/WixToolset.Core.Burn/ExtensibilityServices/BurnBackendHelper.cs b/src/wix/WixToolset.Core.Burn/ExtensibilityServices/BurnBackendHelper.cs
index 93e7fc20..f2b3587d 100644
--- a/src/wix/WixToolset.Core.Burn/ExtensibilityServices/BurnBackendHelper.cs
+++ b/src/wix/WixToolset.Core.Burn/ExtensibilityServices/BurnBackendHelper.cs
@@ -35,21 +35,6 @@ namespace WixToolset.Core.Burn.ExtensibilityServices
 
         #region IBackendHelper interfaces
 
-        public IFileFacade CreateFileFacade(FileSymbol file, AssemblySymbol assembly)
-        {
-            return this.backendHelper.CreateFileFacade(file, assembly);
-        }
-
-        public IFileFacade CreateFileFacade(FileRow fileRow)
-        {
-            return this.backendHelper.CreateFileFacade(fileRow);
-        }
-
-        public IFileFacade CreateFileFacadeFromMergeModule(FileSymbol fileSymbol)
-        {
-            return this.backendHelper.CreateFileFacadeFromMergeModule(fileSymbol);
-        }
-
         public IFileTransfer CreateFileTransfer(string source, string destination, bool move, SourceLineNumber sourceLineNumbers = null)
         {
             return this.backendHelper.CreateFileTransfer(source, destination, move, sourceLineNumbers);
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/AddCreateFoldersCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/AddCreateFoldersCommand.cs
index c4fddb3e..44b66cea 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/AddCreateFoldersCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/AddCreateFoldersCommand.cs
@@ -35,4 +35,4 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs
index 66078d8d..6d37fdc2 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/AttachPatchTransformsCommand.cs
@@ -145,8 +145,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 var mediaSymbol = patchMediaByDiskId[baselineSymbol.DiskId];
 
                 // Ensure that files are sequenced after the last file in any transform.
-                var transformMediaTable = mainTransform.Transform.Tables["Media"];
-                if (null != transformMediaTable && 0 < transformMediaTable.Rows.Count)
+                if (mainTransform.Transform.Tables.TryGetTable("Media", out var transformMediaTable))
                 {
                     foreach (MediaRow transformMediaRow in transformMediaTable.Rows)
                     {
@@ -370,16 +369,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             {
                 if (transform.TryGetTable(tableName, out var table))
                 {
-                    foreach (var row in table.Rows)
+                    foreach (var row in table.Rows.Where(r => r.Operation == RowOperation.Add))
                     {
-                        if (row.Operation == RowOperation.Add)
-                        {
-                            success = false;
+                        success = false;
 
-                            var primaryKey = row.GetPrimaryKey('/') ?? String.Empty;
+                        var primaryKey = row.GetPrimaryKey('/') ?? String.Empty;
 
-                            this.Messaging.Write(ErrorMessages.NewRowAddedInTable(row.SourceLineNumbers, productCode, table.Name, primaryKey));
-                        }
+                        this.Messaging.Write(ErrorMessages.NewRowAddedInTable(row.SourceLineNumbers, productCode, table.Name, primaryKey));
                     }
                 }
             }
@@ -925,7 +921,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 for (var i = 0; i < propertyTable.Rows.Count; ++i)
                 {
                     var propertyRow = propertyTable.Rows[i];
-                    var property = (string)propertyRow[0];
+                    var property = propertyRow.FieldAsString(0);
 
                     if ("ProductCode" == property)
                     {
@@ -1173,10 +1169,15 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             {
                 var pairedFileTable = pairedTransform.EnsureTable(mainFileTable.Definition);
 
-                foreach (FileRow mainFileRow in mainFileTable.Rows)
+                foreach (var mainFileRow in mainFileTable.Rows.Cast<FileRow>())
                 {
-                    // Set File.Sequence to non null to satisfy transform bind.
+                    // Set File.Sequence to non null to satisfy transform bind and suppress any
+                    // change to File.Sequence to avoid bloat.
                     mainFileRow.Sequence = 1;
+                    mainFileRow.Fields[7].Modified = false;
+
+                    // Override authored media to the media provided in the patch.
+                    mainFileRow.DiskId = mediaSymbol.DiskId;
 
                     // Delete's don't need rows in the paired transform.
                     if (mainFileRow.Operation == RowOperation.Delete)
@@ -1188,13 +1189,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     pairedFileRow.Operation = RowOperation.Modify;
                     mainFileRow.CopyTo(pairedFileRow);
 
-                    // Override authored media for patch bind.
-                    mainFileRow.DiskId = mediaSymbol.DiskId;
-
-                    // Suppress any change to File.Sequence to avoid bloat.
-                    mainFileRow.Fields[7].Modified = false;
-
-                    // Force File row to appear in the transform.
+                    // Force modified File rows to appear in the transform.
                     switch (mainFileRow.Operation)
                     {
                         case RowOperation.Modify:
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
index b849aea5..41559f8b 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/BindDatabaseCommand.cs
@@ -21,7 +21,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         // As outlined in RFC 4122, this is our namespace for generating name-based (version 3) UUIDs.
         internal static readonly Guid WixComponentGuidNamespace = new Guid("{3064E5C6-FB63-4FE9-AC49-E446A792EFA5}");
 
-        public BindDatabaseCommand(IBindContext context, IEnumerable<IWindowsInstallerBackendBinderExtension> backendExtension, IEnumerable<SubStorage> subStorages = null)
+        public BindDatabaseCommand(IBindContext context, IEnumerable<IWindowsInstallerBackendBinderExtension> backendExtension, IEnumerable<SubStorage> patchSubStorages = null)
         {
             this.ServiceProvider = context.ServiceProvider;
 
@@ -47,7 +47,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             this.ResolvedLcid = context.ResolvedLcid;
             this.SuppressLayout = context.SuppressLayout;
 
-            this.SubStorages = subStorages;
+            this.PatchSubStorages = patchSubStorages;
 
             this.BackendExtensions = backendExtension;
         }
@@ -76,7 +76,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private IEnumerable<IWindowsInstallerBackendBinderExtension> BackendExtensions { get; }
 
-        private IEnumerable<SubStorage> SubStorages { get; }
+        private IEnumerable<SubStorage> PatchSubStorages { get; }
 
         private Intermediate Intermediate { get; }
 
@@ -180,35 +180,42 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 command.Execute();
             }
 
-#if TODO_PATCHING
-            ////if (OutputType.Patch == this.Output.Type)
-            ////{
-            ////    foreach (SubStorage substorage in this.Output.SubStorages)
-            ////    {
-            ////        Output transform = substorage.Data;
-
-            ////        ResolveFieldsCommand command = new ResolveFieldsCommand();
-            ////        command.Tables = transform.Tables;
-            ////        command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
-            ////        command.FileManagerCore = this.FileManagerCore;
-            ////        command.FileManagers = this.FileManagers;
-            ////        command.SupportDelayedResolution = false;
-            ////        command.TempFilesLocation = this.TempFilesLocation;
-            ////        command.WixVariableResolver = this.WixVariableResolver;
-            ////        command.Execute();
-
-            ////        this.MergeUnrealTables(transform.Tables);
-            ////    }
-            ////}
-#endif
+            // Add missing CreateFolder symbols to null-keypath components.
+            {
+                var command = new AddCreateFoldersCommand(section);
+                command.Execute();
+            }
 
             if (this.Messaging.EncounteredError)
             {
                 return null;
             }
 
-            this.Intermediate.UpdateLevel(Data.WindowsInstaller.IntermediateLevels.FullyBound);
-            this.Messaging.Write(VerboseMessages.UpdatingFileInformation());
+            // Process dependency references.
+            if (SectionType.Product == section.Type || SectionType.Module == section.Type)
+            {
+                var dependencyRefs = section.Symbols.OfType<WixDependencyRefSymbol>().ToList();
+
+                if (dependencyRefs.Any())
+                {
+                    var command = new ProcessDependencyReferencesCommand(this.WindowsInstallerBackendHelper, section, dependencyRefs);
+                    command.Execute();
+                }
+            }
+
+            // Process SoftwareTags in MSI packages.
+            if (SectionType.Product == section.Type)
+            {
+                var softwareTags = section.Symbols.OfType<WixPackageTagSymbol>().ToList();
+
+                if (softwareTags.Any())
+                {
+                    var command = new ProcessPackageSoftwareTagsCommand(section, this.WindowsInstallerBackendHelper, softwareTags, this.IntermediateFolder);
+                    command.Execute();
+
+                    trackedFiles.AddRange(command.TrackedFiles);
+                }
+            }
 
             // Extract files that come from binary .wixlibs and WixExtensions (this does not extract files from merge modules).
             {
@@ -217,21 +224,33 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 trackedFiles.AddRange(extractedFiles);
             }
 
+            // Update symbols that reference text files on disk. Some of those files may have come from .wixlibs and WixExtensions
+            // extracted above.
+            {
+                var command = new UpdateFromTextFilesCommand(this.Messaging, section);
+                command.Execute();
+            }
+
+            this.Intermediate.UpdateLevel(Data.WindowsInstaller.IntermediateLevels.FullyBound);
+            this.Messaging.Write(VerboseMessages.UpdatingFileInformation());
+
             // This must occur after all variables and source paths have been resolved.
-            List<IFileFacade> fileFacades;
-            if (SectionType.Patch == section.Type)
+            List<IFileFacade> allFileFacades;
+            List<IFileFacade> fileFacadesFromIntermediate;
+            List<IFileFacade> fileFacadesFromModule = null;
+            if (section.Type == SectionType.Patch)
             {
-                var command = new GetFileFacadesFromTransforms(this.Messaging, this.WindowsInstallerBackendHelper, this.FileSystemManager, this.SubStorages);
+                var command = new GetFileFacadesFromTransforms(this.Messaging, this.WindowsInstallerBackendHelper, this.FileSystemManager, this.PatchSubStorages);
                 command.Execute();
 
-                fileFacades = command.FileFacades;
+                allFileFacades = fileFacadesFromIntermediate = command.FileFacades;
             }
             else
             {
                 var command = new GetFileFacadesCommand(section, this.WindowsInstallerBackendHelper);
                 command.Execute();
 
-                fileFacades = command.FileFacades;
+                allFileFacades = fileFacadesFromIntermediate = command.FileFacades;
             }
 
             // Retrieve file information from merge modules.
@@ -243,10 +262,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 {
                     containsMergeModules = true;
 
-                    var command = new ExtractMergeModuleFilesCommand(this.Messaging, this.WindowsInstallerBackendHelper, wixMergeSymbols, fileFacades, installerVersion, this.IntermediateFolder, this.SuppressLayout);
+                    var command = new ExtractMergeModuleFilesCommand(this.Messaging, this.WindowsInstallerBackendHelper, wixMergeSymbols, fileFacadesFromIntermediate, installerVersion, this.IntermediateFolder, this.SuppressLayout);
                     command.Execute();
 
-                    fileFacades.AddRange(command.MergeModulesFileFacades);
+                    fileFacadesFromModule = new List<IFileFacade>(command.MergeModulesFileFacades);
+                    allFileFacades.AddRange(fileFacadesFromModule);
                     trackedFiles.AddRange(command.TrackedFiles);
                 }
             }
@@ -257,23 +277,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 return null;
             }
 
-            // Process SoftwareTags in MSI packages.
-            if (SectionType.Product == section.Type)
-            {
-                var softwareTags = section.Symbols.OfType<WixPackageTagSymbol>().ToList();
-
-                if (softwareTags.Any())
-                {
-                    var command = new ProcessPackageSoftwareTagsCommand(section, this.WindowsInstallerBackendHelper, softwareTags, this.IntermediateFolder);
-                    command.Execute();
-
-                    trackedFiles.AddRange(command.TrackedFiles);
-                }
-            }
-
             // Gather information about files that do not come from merge modules.
             {
-                var command = new UpdateFileFacadesCommand(this.Messaging, section, fileFacades, fileFacades.Where(f => !f.FromModule), variableCache, overwriteHash: true);
+                var command = new UpdateFileFacadesCommand(this.Messaging, section, allFileFacades, fileFacadesFromIntermediate, variableCache, overwriteHash: true);
                 command.Execute();
             }
 
@@ -289,18 +295,6 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 this.WindowsInstallerBackendHelper.ResolveDelayedFields(this.DelayedFields, variableCache);
             }
 
-            // Update symbols that reference text files on disk.
-            {
-                var command = new UpdateFromTextFilesCommand(this.Messaging, section);
-                command.Execute();
-            }
-
-            // Add missing CreateFolder symbols to null-keypath components.
-            {
-                var command = new AddCreateFoldersCommand(section);
-                command.Execute();
-            }
-
             // Now that delayed fields are processed, fixup the package version (if needed) and validate it
             // which will short circuit duplicate errors later if the ProductVersion is invalid.
             if (SectionType.Product == section.Type)
@@ -308,18 +302,6 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 this.ProcessProductVersion(packageSymbol, section, validate: true);
             }
 
-            // Process dependency references.
-            if (SectionType.Product == section.Type || SectionType.Module == section.Type)
-            {
-                var dependencyRefs = section.Symbols.OfType<WixDependencyRefSymbol>().ToList();
-
-                if (dependencyRefs.Any())
-                {
-                    var command = new ProcessDependencyReferencesCommand(this.WindowsInstallerBackendHelper, section, dependencyRefs);
-                    command.Execute();
-                }
-            }
-
             // If there are any backend extensions, give them the opportunity to process
             // the section now that the fields have all be resolved.
             //
@@ -339,9 +321,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                     if (reresolvedFiles.Any())
                     {
-                        var updatedFacades = reresolvedFiles.Select(f => fileFacades.First(ff => ff.Id == f.Id?.Id));
+                        var updatedFacades = reresolvedFiles.Select(f => allFileFacades.First(ff => ff.Id == f.Id?.Id));
 
-                        var command = new UpdateFileFacadesCommand(this.Messaging, section, fileFacades, updatedFacades, variableCache, overwriteHash: false);
+                        var command = new UpdateFileFacadesCommand(this.Messaging, section, allFileFacades, updatedFacades, variableCache, overwriteHash: false);
                         command.Execute();
                     }
                 }
@@ -363,28 +345,22 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 }
             }
 
-            // Set generated component guids and validate all guids.
-            {
-                var command = new FinalizeComponentGuids(this.Messaging, this.WindowsInstallerBackendHelper, this.PathResolver, section, platform);
-                command.Execute();
-            }
-
             // Assign files to media and update file sequences.
             Dictionary<MediaSymbol, IEnumerable<IFileFacade>> filesByCabinetMedia;
             IEnumerable<IFileFacade> uncompressedFiles;
             {
-                var order = new OptimizeFileFacadesOrderCommand(this.WindowsInstallerBackendHelper, this.PathResolver, section, platform, fileFacades);
+                var order = new OptimizeFileFacadesOrderCommand(this.WindowsInstallerBackendHelper, this.PathResolver, section, platform, allFileFacades);
                 order.Execute();
 
-                fileFacades = order.FileFacades;
+                allFileFacades = order.FileFacades;
 
-                var assign = new AssignMediaCommand(section, this.Messaging, fileFacades, compressed);
+                var assign = new AssignMediaCommand(section, this.Messaging, allFileFacades, compressed);
                 assign.Execute();
 
                 filesByCabinetMedia = assign.FileFacadesByCabinetMedia;
                 uncompressedFiles = assign.UncompressedFileFacades;
 
-                var update = new UpdateMediaSequencesCommand(section, fileFacades);
+                var update = new UpdateMediaSequencesCommand(section, allFileFacades);
                 update.Execute();
             }
 
@@ -394,6 +370,24 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 return null;
             }
 
+            // Copy updated file facade data back into the transforms or symbols as appropriate.
+            if (section.Type == SectionType.Patch)
+            {
+                var command = new UpdateTransformsWithFileFacades(this.Messaging, section, this.PatchSubStorages, tableDefinitions, allFileFacades);
+                command.Execute();
+            }
+            else
+            {
+                var command = new UpdateSymbolsWithFileFacadesCommand(section, allFileFacades);
+                command.Execute();
+            }
+
+            // Set generated component guids and validate all guids.
+            {
+                var command = new FinalizeComponentGuids(this.Messaging, this.WindowsInstallerBackendHelper, this.PathResolver, section, platform);
+                command.Execute();
+            }
+
             // Time to create the WindowsInstallerData object. Try to put as much above here as possible, updating the IR is better.
             WindowsInstallerData data;
             {
@@ -412,9 +406,19 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 var unsuppress = new AddBackSuppressedSequenceTablesCommand(data, tableDefinitions);
                 suppressedTableNames = unsuppress.Execute();
             }
+            else if (data.Type == OutputType.Product) // we can create instance transforms since Component Guids and Outputs are created.
+            {
+                var command = new CreateInstanceTransformsCommand(section, data, tableDefinitions, this.WindowsInstallerBackendHelper);
+                command.Execute();
+
+                foreach (var storage in command.SubStorages)
+                {
+                    data.SubStorages.Add(storage);
+                }
+            }
             else if (data.Type == OutputType.Patch)
             {
-                foreach (var storage in this.SubStorages)
+                foreach (var storage in this.PatchSubStorages)
                 {
                     data.SubStorages.Add(storage);
                 }
@@ -426,13 +430,9 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 return null;
             }
 
-            // Ensure the intermediate folder is created since delta patches will be
-            // created there.
-            Directory.CreateDirectory(this.IntermediateFolder);
-
-            if (SectionType.Patch == section.Type && this.DeltaBinaryPatch)
+            if (section.Type == SectionType.Patch && this.DeltaBinaryPatch)
             {
-                var command = new CreateDeltaPatchesCommand(fileFacades, this.IntermediateFolder, section.Symbols.OfType<WixPatchSymbol>().FirstOrDefault());
+                var command = new CreateDeltaPatchesCommand(allFileFacades, this.IntermediateFolder, section.Symbols.OfType<WixPatchSymbol>().FirstOrDefault());
                 command.Execute();
             }
 
@@ -454,19 +454,6 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 return null;
             }
 
-            // We can create instance transforms since Component Guids and Outputs are created.
-            if (data.Type == OutputType.Product)
-            {
-                var command = new CreateInstanceTransformsCommand(section, data, tableDefinitions, this.WindowsInstallerBackendHelper);
-                command.Execute();
-            }
-            else if (data.Type == OutputType.Patch)
-            {
-                // Copy output data back into the transforms.
-                var command = new UpdateTransformsWithFileFacades(this.Messaging, data, this.SubStorages, tableDefinitions, fileFacades);
-                command.Execute();
-            }
-
             // Generate database file.
             {
                 this.Messaging.Write(VerboseMessages.GeneratingDatabase());
@@ -491,7 +478,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             {
                 this.Messaging.Write(VerboseMessages.MergingModules());
 
-                var command = new MergeModulesCommand(this.Messaging, this.WindowsInstallerBackendHelper, fileFacades, section, suppressedTableNames, this.OutputPath, this.IntermediateFolder);
+                var command = new MergeModulesCommand(this.Messaging, this.WindowsInstallerBackendHelper, fileFacadesFromModule, section, suppressedTableNames, this.OutputPath, this.IntermediateFolder);
                 command.Execute();
 
                 trackedFiles.AddRange(command.TrackedFiles);
@@ -518,7 +505,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 var fi = new FileInfo(this.OutputPath);
                 if (fi.Length > Int32.MaxValue)
                 {
-                    this.Messaging.Write(WarningMessages.WindowsInstallerFileTooLarge(null, this.OutputPath, "MSI"));
+                    this.Messaging.Write(WarningMessages.WindowsInstallerFileTooLarge(null, this.OutputPath, data.Type.ToString()));
                 }
             }
             catch
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs
index 9acbe475..93aad0a6 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CabinetBuilder.cs
@@ -169,18 +169,24 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 }
             }
 
-            // create the cabinet file
-            var cabinetPath = Path.GetFullPath(cabinetWorkItem.CabinetFile);
+            // Calculate the files to be compressed into the cabinet.
+            var compressFiles = new List<CabinetCompressFile>();
+
+            foreach (var facade in cabinetWorkItem.FileFacades.OrderBy(f => f.Sequence))
+            {
+                var modularizedId = facade.Id + cabinetWorkItem.ModularizationSuffix;
 
-            var files = cabinetWorkItem.FileFacades
-                .OrderBy(f => f.Sequence)
-                .Select(facade => facade.Hash == null ?
-                    new CabinetCompressFile(facade.SourcePath, facade.Id + cabinetWorkItem.ModularizationSuffix) :
-                    new CabinetCompressFile(facade.SourcePath, facade.Id + cabinetWorkItem.ModularizationSuffix, facade.Hash.HashPart1, facade.Hash.HashPart2, facade.Hash.HashPart3, facade.Hash.HashPart4))
-                .ToList();
+                var compressFile = cabinetWorkItem.HashesByFileId.TryGetValue(facade.Id, out var hash) ?
+                    new CabinetCompressFile(facade.SourcePath, modularizedId, hash.HashPart1, hash.HashPart2, hash.HashPart3, hash.HashPart4) :
+                    new CabinetCompressFile(facade.SourcePath, modularizedId);
 
+                compressFiles.Add(compressFile);
+            }
+
+            // create the cabinet file
+            var cabinetPath = Path.GetFullPath(cabinetWorkItem.CabinetFile);
             var cab = new Cabinet(cabinetPath);
-            var created = cab.Compress(files, cabinetWorkItem.CompressionLevel, maxCabinetSize, cabinetWorkItem.MaxThreshold);
+            var created = cab.Compress(compressFiles, cabinetWorkItem.CompressionLevel, maxCabinetSize, cabinetWorkItem.MaxThreshold);
 
             // Best effort check to see if the cabinet is too large for the Windows Installer.
             try
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CabinetWorkItem.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CabinetWorkItem.cs
index 12332c80..d9bc7a7e 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CabinetWorkItem.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CabinetWorkItem.cs
@@ -4,6 +4,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 {
     using System.Collections.Generic;
     using WixToolset.Data;
+    using WixToolset.Data.Symbols;
     using WixToolset.Extensibility.Data;
 
     /// <summary>
@@ -17,11 +18,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         /// <param name="sourceLineNumber">Source line number that requires the cabinet creation.</param>
         /// <param name="diskId"></param>
         /// <param name="fileFacades">The collection of files in this cabinet.</param>
+        /// <param name="hashesByFileId">The hashes for unversioned files.</param>
         /// <param name="cabinetFile">The cabinet file.</param>
         /// <param name="maxThreshold">Maximum threshold for each cabinet.</param>
         /// <param name="compressionLevel">The compression level of the cabinet.</param>
         /// <param name="modularizationSuffix">Modularization suffix used when building a Merge Module.</param>
-        public CabinetWorkItem(SourceLineNumber sourceLineNumber, int diskId, string cabinetFile, IEnumerable<IFileFacade> fileFacades, int maxThreshold, CompressionLevel compressionLevel, string modularizationSuffix)
+        public CabinetWorkItem(SourceLineNumber sourceLineNumber, int diskId, string cabinetFile, IEnumerable<IFileFacade> fileFacades, Dictionary<string, MsiFileHashSymbol> hashesByFileId, int maxThreshold, CompressionLevel compressionLevel, string modularizationSuffix)
         {
             this.SourceLineNumber = sourceLineNumber;
             this.DiskId = diskId;
@@ -29,6 +31,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             this.CompressionLevel = compressionLevel;
             this.ModularizationSuffix = modularizationSuffix;
             this.FileFacades = fileFacades;
+            this.HashesByFileId = hashesByFileId;
             this.MaxThreshold = maxThreshold;
         }
 
@@ -66,6 +69,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         public IEnumerable<IFileFacade> FileFacades { get; }
 
         /// <summary>
+        /// The hashes for unversioned files.
+        /// </summary>
+        public Dictionary<string, MsiFileHashSymbol> HashesByFileId { get; }
+
+        /// <summary>
         /// Gets the max threshold.
         /// </summary>
         /// <value>The maximum threshold for a folder in a cabinet.</value>
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateCabinetsCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateCabinetsCommand.cs
index 6ed107d5..1ed2ba79 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateCabinetsCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateCabinetsCommand.cs
@@ -95,6 +95,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             var cabinetBuilder = new CabinetBuilder(this.Messaging, this.CabbingThreadCount, maximumCabinetSizeForLargeFileSplitting, maximumUncompressedMediaSize);
 
+            var hashesByFileId = this.Section.Symbols.OfType<MsiFileHashSymbol>().ToDictionary(s => s.Id.Id);
+
             foreach (var entry in this.FileFacadesByCabinet)
             {
                 var mediaSymbol = entry.Key;
@@ -102,7 +104,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 var compressionLevel = mediaSymbol.CompressionLevel ?? this.DefaultCompressionLevel ?? CompressionLevel.Medium;
                 var cabinetDir = this.ResolveMedia(mediaSymbol, mediaSymbol.Layout, this.LayoutDirectory);
 
-                var cabinetWorkItem = this.CreateCabinetWorkItem(this.Data, cabinetDir, mediaSymbol, compressionLevel, files);
+                var cabinetWorkItem = this.CreateCabinetWorkItem(this.Data, cabinetDir, mediaSymbol, compressionLevel, files, hashesByFileId);
                 if (null != cabinetWorkItem)
                 {
                     cabinetBuilder.Enqueue(cabinetWorkItem);
@@ -140,16 +142,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             return cabbingThreadCount;
         }
 
-        /// <summary>
-        /// Creates a work item to create a cabinet.
-        /// </summary>
-        /// <param name="data">Windows Installer data for the current database.</param>
-        /// <param name="cabinetDir">Directory to create cabinet in.</param>
-        /// <param name="mediaSymbol">Media symbol containing information about the cabinet.</param>
-        /// <param name="compressionLevel">Desired compression level.</param>
-        /// <param name="fileFacades">Collection of files in this cabinet.</param>
-        /// <returns>created CabinetWorkItem object</returns>
-        private CabinetWorkItem CreateCabinetWorkItem(WindowsInstallerData data, string cabinetDir, MediaSymbol mediaSymbol, CompressionLevel compressionLevel, IEnumerable<IFileFacade> fileFacades)
+        private CabinetWorkItem CreateCabinetWorkItem(WindowsInstallerData data, string cabinetDir, MediaSymbol mediaSymbol, CompressionLevel compressionLevel, IEnumerable<IFileFacade> fileFacades, Dictionary<string, MsiFileHashSymbol> hashesByFileId)
         {
             CabinetWorkItem cabinetWorkItem = null;
 
@@ -171,7 +164,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             if (CabinetBuildOption.BuildAndCopy == resolvedCabinet.BuildOption || CabinetBuildOption.BuildAndMove == resolvedCabinet.BuildOption)
             {
                 // Default to the threshold for best smartcabbing (makes smallest cabinet).
-                cabinetWorkItem = new CabinetWorkItem(mediaSymbol.SourceLineNumbers, mediaSymbol.DiskId, resolvedCabinet.Path, fileFacades, maxThreshold: 0, compressionLevel: compressionLevel, modularizationSuffix: this.ModularizationSuffix);
+                cabinetWorkItem = new CabinetWorkItem(mediaSymbol.SourceLineNumbers, mediaSymbol.DiskId, resolvedCabinet.Path, fileFacades, hashesByFileId, maxThreshold: 0, compressionLevel: compressionLevel, modularizationSuffix: this.ModularizationSuffix);
             }
             else // reuse the cabinet from the cabinet cache.
             {
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateInstanceTransformsCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateInstanceTransformsCommand.cs
index d0e25571..1d480250 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateInstanceTransformsCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateInstanceTransformsCommand.cs
@@ -30,8 +30,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private  IBackendHelper BackendHelper { get; }
 
-        public void Execute()
+        public IReadOnlyCollection<SubStorage> SubStorages { get; private set; }
+
+        public IReadOnlyCollection<SubStorage> Execute()
         {
+            var subStorages = new List<SubStorage>();
+
             // Create and add substorages for instance transforms.
             var wixInstanceTransformsSymbols = this.Section.Symbols.OfType<WixInstanceTransformsSymbol>();
 
@@ -252,9 +256,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                         summaryRow[1] = "4";
                     }
 
-                    this.Output.SubStorages.Add(new SubStorage(instanceId, instanceTransform));
+                    subStorages.Add(new SubStorage(instanceId, instanceTransform));
                 }
             }
+
+            return this.SubStorages = subStorages;
         }
     }
 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs
index 5c993f63..6d5bff69 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreatePatchTransformsCommand.cs
@@ -6,31 +6,44 @@ namespace WixToolset.Core.WindowsInstaller.Bind
     using System.Collections.Generic;
     using System.IO;
     using System.Linq;
-    using WixToolset.Core.Native.Msi;
     using WixToolset.Core.WindowsInstaller.Unbind;
     using WixToolset.Data;
     using WixToolset.Data.Symbols;
     using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Extensibility;
+    using WixToolset.Extensibility.Data;
     using WixToolset.Extensibility.Services;
 
     internal class CreatePatchTransformsCommand
     {
-        public CreatePatchTransformsCommand(IMessaging messaging, IBackendHelper backendHelper, Intermediate intermediate, string intermediateFolder)
+        public CreatePatchTransformsCommand(IMessaging messaging, IBackendHelper backendHelper, IPathResolver pathResolver, IFileResolver fileResolver, IReadOnlyCollection<IResolverExtension> resolverExtensions, Intermediate intermediate, string intermediateFolder, IReadOnlyCollection<IBindPath> bindPaths)
         {
             this.Messaging = messaging;
             this.BackendHelper = backendHelper;
+            this.PathResolver = pathResolver;
+            this.FileResolver = fileResolver;
+            this.ResolverExtensions = resolverExtensions;
             this.Intermediate = intermediate;
             this.IntermediateFolder = intermediateFolder;
+            this.BindPaths = bindPaths;
         }
 
         private IMessaging Messaging { get; }
 
         private IBackendHelper BackendHelper { get; }
 
+        private IPathResolver PathResolver { get; }
+
+        private IFileResolver FileResolver { get; }
+
+        private IReadOnlyCollection<IResolverExtension> ResolverExtensions { get; }
+
         private Intermediate Intermediate { get; }
 
         private string IntermediateFolder { get; }
 
+        private IReadOnlyCollection<IBindPath> BindPaths { get; }
+
         public IEnumerable<PatchTransform> PatchTransforms { get; private set; }
 
         public IEnumerable<PatchTransform> Execute()
@@ -41,23 +54,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             foreach (var symbol in symbols)
             {
-                WindowsInstallerData transform;
-
-                if (symbol.TransformFile is null)
-                {
-                    var baselineData = this.GetData(symbol.BaselineFile.Path);
-                    var updateData = this.GetData(symbol.UpdateFile.Path);
+                var targetData = this.GetWindowsInstallerData(symbol.BaselineFile.Path, BindStage.Target);
+                var updatedData = this.GetWindowsInstallerData(symbol.UpdateFile.Path, BindStage.Updated);
 
-                    var command = new GenerateTransformCommand(this.Messaging, baselineData, updateData, preserveUnchangedRows: true, showPedanticMessages: false);
-                    transform = command.Execute();
-                }
-                else
-                {
-                    var exportBasePath = Path.Combine(this.IntermediateFolder, "_trans"); // TODO: come up with a better path.
-
-                    var command = new UnbindTransformCommand(this.Messaging, this.BackendHelper, symbol.TransformFile.Path, exportBasePath, this.IntermediateFolder);
-                    transform = command.Execute();
-                }
+                var command = new GenerateTransformCommand(this.Messaging, targetData, updatedData, preserveUnchangedRows: true, showPedanticMessages: false);
+                var transform = command.Execute();
 
                 patchTransforms.Add(new PatchTransform(symbol.Id.Id, transform));
             }
@@ -67,26 +68,61 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             return this.PatchTransforms;
         }
 
-        private WindowsInstallerData GetData(string path)
+        private WindowsInstallerData GetWindowsInstallerData(string path, BindStage stage)
         {
-            var ext = Path.GetExtension(path);
-
-            if (".msi".Equals(ext, StringComparison.OrdinalIgnoreCase))
+            if (DataLoader.TryLoadWindowsInstallerData(path, true, out var data))
             {
-                using (var database = new Database(path, OpenDatabase.ReadOnly))
-                {
-                    var exportBasePath = Path.Combine(this.IntermediateFolder, "_msi"); // TODO: come up with a better path.
+                // Re-resolve file paths only when loading from .wixpdb.
+                this.ReResolveWindowsInstallerData(data, stage);
+            }
+            else
+            {
+                var stageFolder = $"_{stage.ToString().ToLowerInvariant()}_msi";
+                var exportBasePath = Path.Combine(this.IntermediateFolder, stageFolder);
+                var extractFilesFolder = Path.Combine(exportBasePath, "File");
+
+                var command = new UnbindDatabaseCommand(this.Messaging, this.BackendHelper, this.PathResolver, path, OutputType.Product, exportBasePath, extractFilesFolder, this.IntermediateFolder, enableDemodularization: false, skipSummaryInfo: false);
+                data = command.Execute();
+            }
 
-                    var isAdminImage = false; // TODO: need a better way to set this
+            return data;
+        }
 
-                    var command = new UnbindDatabaseCommand(this.Messaging, this.BackendHelper, database, path, OutputType.Product, exportBasePath, this.IntermediateFolder, isAdminImage, suppressDemodularization: true, skipSummaryInfo: true);
-                    return command.Execute();
-                }
+        private void ReResolveWindowsInstallerData(WindowsInstallerData data, BindStage stage)
+        {
+            var bindPaths = this.BindPaths.Where(b => b.Stage == stage).ToList();
+
+            if (bindPaths.Count == 0)
+            {
+                return;
             }
-            else // assume .wixpdb (or .wixout)
+
+            foreach (var table in data.Tables)
             {
-                var data = WindowsInstallerData.Load(path, true);
-                return data;
+                foreach (var row in table.Rows)
+                {
+                    foreach (var field in row.Fields.Where(f => f.Column.Type == ColumnType.Object))
+                    {
+                        if (field.PreviousData != null)
+                        {
+                            try
+                            {
+                                var originalPath = field.AsString();
+
+                                var resolvedPath = this.FileResolver.ResolveFile(field.PreviousData, this.ResolverExtensions, bindPaths, stage, row.SourceLineNumbers, null);
+
+                                if (!String.Equals(originalPath, resolvedPath, StringComparison.OrdinalIgnoreCase))
+                                {
+                                    field.Data = resolvedPath;
+                                }
+                            }
+                            catch (WixException e)
+                            {
+                                this.Messaging.Write(e.Error);
+                            }
+                        }
+                    }
+                }
             }
         }
     }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateWindowsInstallerDataFromIRCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateWindowsInstallerDataFromIRCommand.cs
index 60317cd9..4d99ff40 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateWindowsInstallerDataFromIRCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/CreateWindowsInstallerDataFromIRCommand.cs
@@ -662,10 +662,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             row.FileSize = symbol.FileSize;
             row.Version = symbol.Version;
             row.Language = symbol.Language;
-            row.DiskId = symbol.DiskId ?? 1; // TODO: is 1 the correct thing to default here
             row.Sequence = symbol.Sequence;
+            row.DiskId = symbol.DiskId ?? throw new InvalidDataException("FileSymbol.DiskId should have been initialized before creating WindowsInstallerData from IntermediateRepresentation.");
             row.Source = symbol.Source.Path;
 
+            var previousSourceField = symbol.Fields[(int)FileSymbolFields.Source]?.PreviousValue;
+            row.PreviousSource = previousSourceField?.AsPath().Path;
+
             var attributes = (symbol.Attributes & FileSymbolAttributes.Checksum) == FileSymbolAttributes.Checksum ? WindowsInstallerConstants.MsidbFileAttributesChecksum : 0;
             attributes |= (symbol.Attributes & FileSymbolAttributes.Compressed) == FileSymbolAttributes.Compressed ? WindowsInstallerConstants.MsidbFileAttributesCompressed : 0;
             attributes |= (symbol.Attributes & FileSymbolAttributes.Uncompressed) == FileSymbolAttributes.Uncompressed ? WindowsInstallerConstants.MsidbFileAttributesNoncompressed : 0;
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/DataLoader.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/DataLoader.cs
new file mode 100644
index 00000000..6214bbdb
--- /dev/null
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/DataLoader.cs
@@ -0,0 +1,49 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.WindowsInstaller.Bind
+{
+    using System;
+    using System.IO;
+    using WixToolset.Data.WindowsInstaller;
+
+    internal class DataLoader
+    {
+        public static bool TryLoadWindowsInstallerData(string path, out WindowsInstallerData data)
+        {
+            return TryLoadWindowsInstallerData(path, false, out data);
+        }
+
+        public static bool TryLoadWindowsInstallerData(string path, bool suppressVersionCheck, out WindowsInstallerData data)
+        {
+            data = null;
+
+            var extension = Path.GetExtension(path);
+
+            // If the path is _not_ obviously a Windows Installer database, let's try opening it as
+            // our own data file format.
+            if (!extension.Equals(".msi", StringComparison.OrdinalIgnoreCase) && !extension.Equals(".msm", StringComparison.OrdinalIgnoreCase))
+            {
+                (data, _) = LoadWindowsInstallerDataSafely(path, suppressVersionCheck);
+            }
+
+            return data != null;
+        }
+
+        public static (WindowsInstallerData, Exception) LoadWindowsInstallerDataSafely(string path, bool suppressVersionCheck = false)
+        {
+            WindowsInstallerData data = null;
+            Exception exception = null;
+
+            try
+            {
+                data = WindowsInstallerData.Load(path, suppressVersionCheck);
+            }
+            catch (Exception e)
+            {
+                exception = e;
+            }
+
+            return (data, exception);
+        }
+    }
+}
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs
index 06168727..94ed0afc 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/ExtractMergeModuleFilesCommand.cs
@@ -22,12 +22,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
     /// </summary>
     internal class ExtractMergeModuleFilesCommand
     {
-        public ExtractMergeModuleFilesCommand(IMessaging messaging, IWindowsInstallerBackendHelper backendHelper, IEnumerable<WixMergeSymbol> wixMergeSymbols, IEnumerable<IFileFacade> fileFacades, int installerVersion, string intermediateFolder, bool suppressLayout)
+        public ExtractMergeModuleFilesCommand(IMessaging messaging, IWindowsInstallerBackendHelper backendHelper, IEnumerable<WixMergeSymbol> wixMergeSymbols, IEnumerable<IFileFacade> fileFacadesFromIntermediate, int installerVersion, string intermediateFolder, bool suppressLayout)
         {
             this.Messaging = messaging;
             this.BackendHelper = backendHelper;
             this.WixMergeSymbols = wixMergeSymbols;
-            this.FileFacades = fileFacades;
+            this.FileFacadesFromIntermediate = fileFacadesFromIntermediate;
             this.OutputInstallerVersion = installerVersion;
             this.IntermediateFolder = intermediateFolder;
             this.SuppressLayout = suppressLayout;
@@ -39,7 +39,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private IEnumerable<WixMergeSymbol> WixMergeSymbols { get; }
 
-        private IEnumerable<IFileFacade> FileFacades { get; }
+        private IEnumerable<IFileFacade> FileFacadesFromIntermediate { get; }
 
         private int OutputInstallerVersion { get; }
 
@@ -65,7 +65,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             // Now since Merge Modules are already slow and generally less desirable than .wixlibs we'll let
             // this case be slightly more expensive because the cost of maintaining an indexed file row collection
             // is a lot more costly for the common cases.
-            var indexedFileFacades = this.FileFacades.ToDictionary(f => f.Id, StringComparer.Ordinal);
+            var indexedFileFacades = this.FileFacadesFromIntermediate.ToDictionary(f => f.Id, StringComparer.Ordinal);
 
             foreach (var wixMergeRow in this.WixMergeSymbols)
             {
@@ -115,7 +115,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                 fileSymbol.DiskId = wixMergeRow.DiskId;
                                 fileSymbol.Source = new IntermediateFieldPathValue { Path = Path.Combine(this.IntermediateFolder, wixMergeRow.Id.Id, record[1]) };
 
-                                var mergeModuleFileFacade = this.BackendHelper.CreateFileFacadeFromMergeModule(fileSymbol);
+                                var mergeModuleFileFacade = this.BackendHelper.CreateFileFacade(fileSymbol);
 
                                 // If case-sensitive collision with another merge module or a user-authored file identifier.
                                 if (indexedFileFacades.TryGetValue(mergeModuleFileFacade.Id, out var collidingFacade))
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs
index 575065bb..92a0e11f 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/GenerateTransformCommand.cs
@@ -16,7 +16,7 @@ namespace WixToolset.Core.WindowsInstaller
     /// </summary>
     internal class GenerateTransformCommand
     {
-        private const char sectionDelimiter = '/';
+        private const char SectionDelimiter = '/';
         private readonly IMessaging messaging;
         private SummaryInformationStreams transformSummaryInfo;
 
@@ -38,22 +38,10 @@ namespace WixToolset.Core.WindowsInstaller
 
         private TransformFlags ValidationFlags { get; }
 
-        /// <summary>
-        /// Gets or sets the option to show pedantic messages.
-        /// </summary>
-        /// <value>The option to show pedantic messages.</value>
         private bool ShowPedanticMessages { get; }
 
-        /// <summary>
-        /// Gets or sets the option to suppress keeping special rows.
-        /// </summary>
-        /// <value>The option to suppress keeping special rows.</value>
         private bool SuppressKeepingSpecialRows { get; }
 
-        /// <summary>
-        /// Gets or sets the flag to determine if all rows, even unchanged ones will be persisted in the output.
-        /// </summary>
-        /// <value>The option to keep all rows including unchanged rows.</value>
         private bool PreserveUnchangedRows { get; }
 
         public WindowsInstallerData Transform { get; private set; }
@@ -124,7 +112,7 @@ namespace WixToolset.Core.WindowsInstaller
                     foreach (var updatedRow in updatedTable.Rows)
                     {
                         updatedRow.Operation = RowOperation.Add;
-                        updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId;
+                        updatedRow.SectionId = SectionDelimiter + updatedRow.SectionId;
                         addedTable.Rows.Add(updatedRow);
                     }
                 }
@@ -152,27 +140,8 @@ namespace WixToolset.Core.WindowsInstaller
 
             if (null != primaryKey)
             {
-                if (index.TryGetValue(primaryKey, out var collisionRow))
+                if (index.ContainsKey(primaryKey))
                 {
-#if TODO_PATCH // This case doesn't seem like it can happen any longer.
-                    // Overriding WixActionRows have a primary key defined and take precedence in the index.
-                    if (row is WixActionRow actionRow)
-                    {
-                        // If the current row is not overridable, see if the indexed row is.
-                        if (!actionRow.Overridable)
-                        {
-                            if (collisionRow is WixActionRow indexedRow && indexedRow.Overridable)
-                            {
-                                // The indexed key is overridable and should be replaced.
-                                index[primaryKey] = actionRow;
-                            }
-                        }
-
-                        // If we got this far, the row does not need to be indexed.
-                        return;
-                    }
-#endif
-
                     if (this.ShowPedanticMessages)
                     {
                         this.messaging.Write(ErrorMessages.DuplicatePrimaryKey(row.SourceLineNumbers, primaryKey, row.Table.Name));
@@ -208,7 +177,7 @@ namespace WixToolset.Core.WindowsInstaller
                 else if (null == updatedRow)
                 {
                     targetRow.Operation = RowOperation.Delete;
-                    targetRow.SectionId += sectionDelimiter;
+                    targetRow.SectionId += SectionDelimiter;
 
                     comparedRow = targetRow;
                     keepRow = true;
@@ -219,10 +188,10 @@ namespace WixToolset.Core.WindowsInstaller
                 updatedRow.Operation = RowOperation.None;
                 if (!this.SuppressKeepingSpecialRows && "_SummaryInformation" == targetTable.Name)
                 {
-                    // ignore rows that shouldn't be in a transform
+                    // Include only summary information rows that are allowed in a transform.
                     if (Enum.IsDefined(typeof(SummaryInformation.Transform), (int)updatedRow[0]))
                     {
-                        updatedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
+                        updatedRow.SectionId = targetRow.SectionId + SectionDelimiter + updatedRow.SectionId;
                         comparedRow = updatedRow;
                         keepRow = true;
                     }
@@ -273,14 +242,14 @@ namespace WixToolset.Core.WindowsInstaller
                                 updatedObjectField.PreviousEmbeddedFileIndex = targetObjectField.EmbeddedFileIndex;
                                 updatedObjectField.PreviousBaseUri = targetObjectField.BaseUri;
 
-                                // always keep a copy of the previous data even if they are identical
-                                // This makes diff.wixmst clean and easier to control patch logic
+                                // Always keep a copy of the previous data even if they are identical.
+                                // This makes diff data clean and easier to control in patch logic.
                                 updatedObjectField.PreviousData = (string)targetObjectField.Data;
 
-                                // always remember the unresolved data for target build
+                                // Always remember the unresolved data for target build.
                                 updatedObjectField.UnresolvedPreviousData = targetObjectField.UnresolvedData;
 
-                                // keep rows containing object fields so the files can be compared in the binder
+                                // Keep rows containing object fields so the files can be compared later.
                                 keepRow = !this.SuppressKeepingSpecialRows;
                             }
                             else
@@ -305,7 +274,7 @@ namespace WixToolset.Core.WindowsInstaller
                     if (keepRow)
                     {
                         comparedRow = updatedRow;
-                        comparedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
+                        comparedRow.SectionId = targetRow.SectionId + SectionDelimiter + updatedRow.SectionId;
                     }
                 }
             }
@@ -333,9 +302,6 @@ namespace WixToolset.Core.WindowsInstaller
             }
             else // possibly modified table.
             {
-                var updatedPrimaryKeys = new Dictionary<string, Row>();
-                var targetPrimaryKeys = new Dictionary<string, Row>();
-
                 // compare the table definitions
                 if (0 != targetTable.Definition.CompareTo(updatedTable.Definition))
                 {
@@ -344,6 +310,9 @@ namespace WixToolset.Core.WindowsInstaller
                 }
                 else
                 {
+                    var updatedPrimaryKeys = new Dictionary<string, Row>();
+                    var targetPrimaryKeys = new Dictionary<string, Row>();
+
                     this.IndexPrimaryKeys(targetTable, targetPrimaryKeys, updatedTable, updatedPrimaryKeys);
 
                     // diff the target and updated rows
@@ -371,7 +340,7 @@ namespace WixToolset.Core.WindowsInstaller
                             var updatedRow = updatedPrimaryKeyEntry.Value;
 
                             updatedRow.Operation = RowOperation.Add;
-                            updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId;
+                            updatedRow.SectionId = SectionDelimiter + updatedRow.SectionId;
                             rows.Add(updatedRow);
                         }
                     }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs
index 949d5e18..fa072293 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesCommand.cs
@@ -2,9 +2,7 @@
 
 namespace WixToolset.Core.WindowsInstaller.Bind
 {
-    using System;
     using System.Collections.Generic;
-    using System.Globalization;
     using System.Linq;
     using WixToolset.Data;
     using WixToolset.Data.Symbols;
@@ -29,20 +27,17 @@ namespace WixToolset.Core.WindowsInstaller.Bind
         {
             var facades = new List<IFileFacade>();
 
-            var assemblyFile = this.Section.Symbols.OfType<AssemblySymbol>().ToDictionary(t => t.Id.Id);
 #if TODO_PATCHING_DELTA
             //var deltaPatchFiles = this.Section.Symbols.OfType<WixDeltaPatchFileSymbol>().ToDictionary(t => t.Id.Id);
 #endif
 
             foreach (var file in this.Section.Symbols.OfType<FileSymbol>())
             {
-                assemblyFile.TryGetValue(file.Id.Id, out var assembly);
-
 #if TODO_PATCHING_DELTA
                 //deltaPatchFiles.TryGetValue(file.Id.Id, out var deltaPatchFile);
                 // TODO: should we be passing along delta information to the file facade? Probably, right?
 #endif
-                var fileFacade = this.BackendHelper.CreateFileFacade(file, assembly);
+                var fileFacade = this.BackendHelper.CreateFileFacade(file);
 
                 facades.Add(fileFacade);
             }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs
index 441038ec..7c71e238 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/GetFileFacadesFromTransforms.cs
@@ -37,8 +37,6 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
             var patchMediaFileRows = new Dictionary<int, RowDictionary<FileRow>>();
 
-            //var patchActualFileTable = this.Output.EnsureTable(this.TableDefinitions["File"]);
-
             // Index paired transforms by name without their "#" prefix.
             var pairedTransforms = this.SubStorages.Where(s => s.Name.StartsWith(PatchConstants.PairedPatchTransformPrefix)).ToDictionary(s => s.Name, s => s.Data);
 
@@ -57,7 +55,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 var pairedTransform = pairedTransforms[PatchConstants.PairedPatchTransformPrefix + substorage.Name];
                 var pairedFileRows = new RowDictionary<FileRow>(pairedTransform.Tables["File"]);
 
-                foreach (FileRow mainFileRow in mainFileTable.Rows.Where(f => f.Operation != RowOperation.Delete))
+                foreach (var mainFileRow in mainFileTable.Rows.Where(f => f.Operation != RowOperation.Delete).Cast<FileRow>())
                 {
                     var mainFileId = mainFileRow.File;
 
@@ -89,8 +87,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                         }
                         else
                         {
-                            // TODO: should this entire condition be placed in the binder file manager?
-                            if (/*(0 == (PatchAttributeType.Ignore & mainWixFileRow.PatchAttributes)) &&*/
+                            if (
+#if TODO_PATCHING_DELTA
+                                (0 == (PatchAttributeType.Ignore & mainWixFileRow.PatchAttributes)) &&
+#endif
                                 !this.FileSystemManager.CompareFiles(objectField.PreviousData, objectField.Data.ToString()))
                             {
                                 // If the file is different, we need to mark the mainFileRow and pairedFileRow as modified.
@@ -133,11 +133,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                         patchMediaFileRows.Add(diskId, mediaFileRows);
                     }
 
-                    var patchFileRow = mediaFileRows.Get(mainFileId);
-
-                    if (null == patchFileRow)
+                    if (!mediaFileRows.TryGetValue(mainFileId, out var patchFileRow))
                     {
-                        //patchFileRow = (FileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers);
                         patchFileRow = (FileRow)mainFileRow.TableDefinition.CreateRow(mainFileRow.SourceLineNumbers);
                         mainFileRow.CopyTo(patchFileRow);
 
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs
index 7e6a7de0..5f21f496 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/MergeModulesCommand.cs
@@ -10,7 +10,6 @@ namespace WixToolset.Core.WindowsInstaller.Bind
     using System.Runtime.InteropServices;
     using System.Text;
     using System.Threading;
-    using WixToolset.Core.Native;
     using WixToolset.Core.Native.Msi;
     using WixToolset.Core.Native.Msm;
     using WixToolset.Data;
@@ -24,11 +23,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
     /// </summary>
     internal class MergeModulesCommand
     {
-        public MergeModulesCommand(IMessaging messaging, IBackendHelper backendHelper, IEnumerable<IFileFacade> fileFacades, IntermediateSection section, IEnumerable<string> suppressedTableNames, string outputPath, string intermediateFolder)
+        public MergeModulesCommand(IMessaging messaging, IBackendHelper backendHelper, IEnumerable<IFileFacade> fileFacadesFromModule, IntermediateSection section, IEnumerable<string> suppressedTableNames, string outputPath, string intermediateFolder)
         {
             this.Messaging = messaging;
             this.BackendHelper = backendHelper;
-            this.FileFacades = fileFacades;
+            this.FileFacadesFromModule = fileFacadesFromModule;
             this.Section = section;
             this.SuppressedTableNames = suppressedTableNames ?? Array.Empty<string>();
             this.OutputPath = outputPath;
@@ -39,7 +38,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private IBackendHelper BackendHelper { get; }
 
-        private IEnumerable<IFileFacade> FileFacades { get; }
+        private IEnumerable<IFileFacade> FileFacadesFromModule { get; }
 
         private IntermediateSection Section { get; }
 
@@ -280,13 +279,8 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 this.Messaging.Write(VerboseMessages.ResequencingMergeModuleFiles());
                 using (var view = db.OpenView("SELECT `Sequence`, `Attributes` FROM `File` WHERE `File`=?"))
                 {
-                    foreach (var file in this.FileFacades)
+                    foreach (var file in this.FileFacadesFromModule)
                     {
-                        if (!file.FromModule)
-                        {
-                            continue;
-                        }
-
                         using (var record = new Record(1))
                         {
                             record.SetString(1, file.Id);
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/ProcessPropertiesCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/ProcessPropertiesCommand.cs
index 217609be..1f09a267 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/ProcessPropertiesCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/ProcessPropertiesCommand.cs
@@ -47,28 +47,6 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     if ("ProductCode" == propertySymbol.Id.Id && "*".Equals(propertySymbol.Value, StringComparison.Ordinal))
                     {
                         propertySymbol.Value = this.BackendHelper.CreateGuid();
-
-#if TODO_PATCHING // Is this still necessary?
-                        // Update the target ProductCode in any instance transforms.
-                        foreach (SubStorage subStorage in this.Output.SubStorages)
-                        {
-                            Output subStorageOutput = subStorage.Data;
-                            if (OutputType.Transform != subStorageOutput.Type)
-                            {
-                                continue;
-                            }
-
-                            Table instanceSummaryInformationTable = subStorageOutput.Tables["_SummaryInformation"];
-                            foreach (Row row in instanceSummaryInformationTable.Rows)
-                            {
-                                if ((int)SummaryInformation.Transform.ProductCodes == row.FieldAsInteger(0))
-                                {
-                                    row[1] = row.FieldAsString(1).Replace("*", propertyRow.Value);
-                                    break;
-                                }
-                            }
-                        }
-#endif
                     }
                     else if ("ProductLanguage" == propertySymbol.Id.Id)
                     {
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs
index 8043ffa8..f2f8e126 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateFileFacadesCommand.cs
@@ -19,11 +19,11 @@ namespace WixToolset.Core.WindowsInstaller.Bind
     /// </summary>
     internal class UpdateFileFacadesCommand
     {
-        public UpdateFileFacadesCommand(IMessaging messaging, IntermediateSection section, IEnumerable<IFileFacade> fileFacades, IEnumerable<IFileFacade> updateFileFacades, IDictionary<string, string> variableCache, bool overwriteHash)
+        public UpdateFileFacadesCommand(IMessaging messaging, IntermediateSection section, IEnumerable<IFileFacade> allFileFacades, IEnumerable<IFileFacade> updateFileFacades, IDictionary<string, string> variableCache, bool overwriteHash)
         {
             this.Messaging = messaging;
             this.Section = section;
-            this.FileFacades = fileFacades;
+            this.AllFileFacades = allFileFacades;
             this.UpdateFileFacades = updateFileFacades;
             this.VariableCache = variableCache;
             this.OverwriteHash = overwriteHash;
@@ -33,7 +33,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private IntermediateSection Section { get; }
 
-        private IEnumerable<IFileFacade> FileFacades { get; }
+        private IEnumerable<IFileFacade> AllFileFacades { get; }
 
         private IEnumerable<IFileFacade> UpdateFileFacades { get; }
 
@@ -43,15 +43,16 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         public void Execute()
         {
+            var assemblySymbols = this.Section.Symbols.OfType<AssemblySymbol>().ToDictionary(t => t.Id.Id);
             var assemblyNameSymbols = this.Section.Symbols.OfType<MsiAssemblyNameSymbol>().ToDictionary(t => t.Id.Id);
 
             foreach (var file in this.UpdateFileFacades.Where(f => f.SourcePath != null))
             {
-                this.UpdateFileFacade(file, assemblyNameSymbols);
+                this.UpdateFileFacade(file, assemblySymbols, assemblyNameSymbols);
             }
         }
 
-        private void UpdateFileFacade(IFileFacade facade, Dictionary<string, MsiAssemblyNameSymbol> assemblyNameSymbols)
+        private void UpdateFileFacade(IFileFacade facade, Dictionary<string, AssemblySymbol> assemblySymbols, Dictionary<string, MsiAssemblyNameSymbol> assemblyNameSymbols)
         {
             FileInfo fileInfo = null;
             try
@@ -124,7 +125,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                     //
                     // Also, if we do not find a matching file identifier then the user provided a default version and is providing a version
                     // for unversioned file. That's allowed but generally a dangerous thing to do so let's point that out to the user.
-                    if (!this.FileFacades.Any(r => facade.Version.Equals(r.Id, StringComparison.Ordinal)))
+                    if (!this.AllFileFacades.Any(r => facade.Version.Equals(r.Id, StringComparison.Ordinal)))
                     {
                         this.Messaging.Write(WarningMessages.DefaultVersionUsedForUnversionedFile(facade.SourceLineNumber, facade.Version, facade.Id));
                     }
@@ -153,16 +154,15 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                         }
                     }
 
-                    if (null == facade.Hash)
+                    // Remember the hash symbol for use later.
+                    facade.MsiFileHashSymbol = new MsiFileHashSymbol(facade.SourceLineNumber, facade.Identifier)
                     {
-                        facade.Hash = this.Section.AddSymbol(new MsiFileHashSymbol(facade.SourceLineNumber, facade.Identifier));
-                    }
-
-                    facade.Hash.Options = 0;
-                    facade.Hash.HashPart1 = hash[0];
-                    facade.Hash.HashPart2 = hash[1];
-                    facade.Hash.HashPart3 = hash[2];
-                    facade.Hash.HashPart4 = hash[3];
+                        Options = 0,
+                        HashPart1 = hash[0],
+                        HashPart2 = hash[1],
+                        HashPart3 = hash[2],
+                        HashPart4 = hash[3],
+                    };
                 }
             }
             else // update the file row with the version and language information.
@@ -173,7 +173,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 {
                     facade.Version = version;
                 }
-                else if (!this.FileFacades.Any(r => facade.Version.Equals(r.Id, StringComparison.Ordinal))) // this looks expensive, but see explanation below.
+                else if (!this.AllFileFacades.Any(r => facade.Version.Equals(r.Id, StringComparison.Ordinal))) // this looks expensive, but see explanation below.
                 {
                     // The user provided a default version for the file row so we looked for a companion file (a file row with Id matching
                     // the version value). We didn't find it so, we will override the default version they provided with the actual
@@ -204,108 +204,104 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 this.VariableCache[$"filelanguage.{facade.Id}"] = facade.Language ?? String.Empty;
             }
 
-            // If this is a CLR assembly, load the assembly and get the assembly name information
-            if (AssemblyType.DotNetAssembly == facade.AssemblyType)
+            // If there is an assembly for this file.
+            if (assemblySymbols.TryGetValue(facade.Id, out var assemblySymbol))
             {
-                try
+                // If this is a CLR assembly, load the assembly and get the assembly name information
+                if (AssemblyType.DotNetAssembly == assemblySymbol.Type)
                 {
-                    var assemblyName = AssemblyNameReader.ReadAssembly(facade.SourceLineNumber, fileInfo.FullName, version);
+                    try
+                    {
+                        var assemblyName = AssemblyNameReader.ReadAssembly(facade.SourceLineNumber, fileInfo.FullName, version);
 
-                    this.SetMsiAssemblyName(assemblyNameSymbols, facade, "name", assemblyName.Name);
-                    this.SetMsiAssemblyName(assemblyNameSymbols, facade, "culture", assemblyName.Culture);
-                    this.SetMsiAssemblyName(assemblyNameSymbols, facade, "version", assemblyName.Version);
+                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "name", assemblyName.Name);
+                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "culture", assemblyName.Culture);
+                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "version", assemblyName.Version);
 
-                    if (!String.IsNullOrEmpty(assemblyName.Architecture))
-                    {
-                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, "processorArchitecture", assemblyName.Architecture);
-                    }
-                    // TODO: WiX v3 seemed to do this but not clear it should actually be done.
-                    //else if (!String.IsNullOrEmpty(file.WixFile.ProcessorArchitecture))
-                    //{
-                    //    this.SetMsiAssemblyName(assemblyNameSymbols, file, "processorArchitecture", file.WixFile.ProcessorArchitecture);
-                    //}
+                        if (!String.IsNullOrEmpty(assemblyName.Architecture))
+                        {
+                            this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "processorArchitecture", assemblyName.Architecture);
+                        }
+                        // TODO: WiX v3 seemed to do this but not clear it should actually be done.
+                        //else if (!String.IsNullOrEmpty(file.WixFile.ProcessorArchitecture))
+                        //{
+                        //    this.SetMsiAssemblyName(assemblyNameSymbols, file, "processorArchitecture", file.WixFile.ProcessorArchitecture);
+                        //}
 
-                    if (assemblyName.StrongNamedSigned)
-                    {
-                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, "publicKeyToken", assemblyName.PublicKeyToken);
-                    }
-                    else if (facade.AssemblyApplicationFileRef == null)
-                    {
-                        throw new WixException(ErrorMessages.GacAssemblyNoStrongName(facade.SourceLineNumber, fileInfo.FullName, facade.ComponentRef));
-                    }
+                        if (assemblyName.StrongNamedSigned)
+                        {
+                            this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "publicKeyToken", assemblyName.PublicKeyToken);
+                        }
+                        else if (assemblySymbol.ApplicationFileRef == null)
+                        {
+                            throw new WixException(ErrorMessages.GacAssemblyNoStrongName(facade.SourceLineNumber, fileInfo.FullName, facade.ComponentRef));
+                        }
 
-                    if (!String.IsNullOrEmpty(assemblyName.FileVersion))
-                    {
-                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, "fileVersion", assemblyName.FileVersion);
-                    }
+                        if (!String.IsNullOrEmpty(assemblyName.FileVersion))
+                        {
+                            this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "fileVersion", assemblyName.FileVersion);
+                        }
 
-                    // add the assembly name to the information cache
-                    if (null != this.VariableCache)
+                        // add the assembly name to the information cache
+                        if (null != this.VariableCache)
+                        {
+                            this.VariableCache[$"assemblyfullname.{facade.Id}"] = assemblyName.GetFullName();
+                        }
+                    }
+                    catch (WixException e)
                     {
-                        this.VariableCache[$"assemblyfullname.{facade.Id}"] = assemblyName.GetFullName();
+                        this.Messaging.Write(e.Error);
                     }
                 }
-                catch (WixException e)
-                {
-                    this.Messaging.Write(e.Error);
-                }
-            }
-            else if (AssemblyType.Win32Assembly == facade.AssemblyType)
-            {
-                // TODO: Consider passing in the this.FileFacades as an indexed collection instead of searching through
-                // all files like this. Even though this is a rare case it looks like we might be able to index the
-                // file earlier.
-                var fileManifest = this.FileFacades.FirstOrDefault(r => r.Id.Equals(facade.AssemblyManifestFileRef, StringComparison.Ordinal));
-                if (null == fileManifest)
-                {
-                    this.Messaging.Write(ErrorMessages.MissingManifestForWin32Assembly(facade.SourceLineNumber, facade.Id, facade.AssemblyManifestFileRef));
-                }
-
-                try
+                else if (AssemblyType.Win32Assembly == assemblySymbol.Type)
                 {
-                    var assemblyName = AssemblyNameReader.ReadAssemblyManifest(facade.SourceLineNumber, fileManifest.SourcePath);
-
-                    if (!String.IsNullOrEmpty(assemblyName.Name))
+                    // TODO: Consider passing in the this.AllFileFacades as an indexed collection instead of searching through
+                    // all files like this. Even though this is a rare case it looks like we might be able to index the
+                    // file earlier.
+                    var fileManifest = this.AllFileFacades.FirstOrDefault(r => r.Id.Equals(assemblySymbol.ManifestFileRef, StringComparison.Ordinal));
+                    if (null == fileManifest)
                     {
-                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, "name", assemblyName.Name);
+                        this.Messaging.Write(ErrorMessages.MissingManifestForWin32Assembly(facade.SourceLineNumber, facade.Id, assemblySymbol.ManifestFileRef));
                     }
 
-                    if (!String.IsNullOrEmpty(assemblyName.Version))
+                    try
                     {
-                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, "version", assemblyName.Version);
-                    }
+                        var assemblyName = AssemblyNameReader.ReadAssemblyManifest(facade.SourceLineNumber, fileManifest.SourcePath);
 
-                    if (!String.IsNullOrEmpty(assemblyName.Type))
-                    {
-                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, "type", assemblyName.Type);
-                    }
+                        if (!String.IsNullOrEmpty(assemblyName.Name))
+                        {
+                            this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "name", assemblyName.Name);
+                        }
 
-                    if (!String.IsNullOrEmpty(assemblyName.Architecture))
-                    {
-                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, "processorArchitecture", assemblyName.Architecture);
-                    }
+                        if (!String.IsNullOrEmpty(assemblyName.Version))
+                        {
+                            this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "version", assemblyName.Version);
+                        }
+
+                        if (!String.IsNullOrEmpty(assemblyName.Type))
+                        {
+                            this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "type", assemblyName.Type);
+                        }
+
+                        if (!String.IsNullOrEmpty(assemblyName.Architecture))
+                        {
+                            this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "processorArchitecture", assemblyName.Architecture);
+                        }
 
-                    if (!String.IsNullOrEmpty(assemblyName.PublicKeyToken))
+                        if (!String.IsNullOrEmpty(assemblyName.PublicKeyToken))
+                        {
+                            this.SetMsiAssemblyName(assemblyNameSymbols, facade, assemblySymbol, "publicKeyToken", assemblyName.PublicKeyToken);
+                        }
+                    }
+                    catch (WixException e)
                     {
-                        this.SetMsiAssemblyName(assemblyNameSymbols, facade, "publicKeyToken", assemblyName.PublicKeyToken);
+                        this.Messaging.Write(e.Error);
                     }
                 }
-                catch (WixException e)
-                {
-                    this.Messaging.Write(e.Error);
-                }
             }
         }
 
-        /// <summary>
-        /// Set an MsiAssemblyName row.  If it was directly authored, override the value, otherwise
-        /// create a new row.
-        /// </summary>
-        /// <param name="assemblyNameSymbols">MsiAssemblyName table.</param>
-        /// <param name="facade">FileFacade containing the assembly read for the MsiAssemblyName row.</param>
-        /// <param name="name">MsiAssemblyName name.</param>
-        /// <param name="value">MsiAssemblyName value.</param>
-        private void SetMsiAssemblyName(Dictionary<string, MsiAssemblyNameSymbol> assemblyNameSymbols, IFileFacade facade, string name, string value)
+        private void SetMsiAssemblyName(Dictionary<string, MsiAssemblyNameSymbol> assemblyNameSymbols, IFileFacade facade, AssemblySymbol assemblySymbol, string name, string value)
         {
             // check for null value (this can occur when grabbing the file version from an assembly without one)
             if (String.IsNullOrEmpty(value))
@@ -315,36 +311,32 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             else
             {
                 // if the assembly will be GAC'd and the name in the file table doesn't match the name in the MsiAssemblyName table, error because the install will fail.
-                if ("name" == name && AssemblyType.DotNetAssembly == facade.AssemblyType &&
-                    String.IsNullOrEmpty(facade.AssemblyApplicationFileRef) &&
+                if ("name" == name && AssemblyType.DotNetAssembly == assemblySymbol.Type &&
+                    String.IsNullOrEmpty(assemblySymbol.ApplicationFileRef) &&
                     !String.Equals(Path.GetFileNameWithoutExtension(facade.FileName), value, StringComparison.OrdinalIgnoreCase))
                 {
                     this.Messaging.Write(ErrorMessages.GACAssemblyIdentityWarning(facade.SourceLineNumber, Path.GetFileNameWithoutExtension(facade.FileName), value));
                 }
 
-                // override directly authored value
+                // Override directly authored value, otherwise remember the gathered information on the facade for use later.
                 var lookup = String.Concat(facade.ComponentRef, "/", name);
-                if (!assemblyNameSymbols.TryGetValue(lookup, out var assemblyNameSymbol))
+                if (assemblyNameSymbols.TryGetValue(lookup, out var assemblyNameSymbol))
                 {
-                    assemblyNameSymbol = this.Section.AddSymbol(new MsiAssemblyNameSymbol(facade.SourceLineNumber, new Identifier(AccessModifier.Section, facade.ComponentRef, name))
+                    assemblyNameSymbol.Value = value;
+                }
+                else
+                {
+                    assemblyNameSymbol = new MsiAssemblyNameSymbol(assemblySymbol.SourceLineNumbers, new Identifier(AccessModifier.Section, facade.ComponentRef, name))
                     {
                         ComponentRef = facade.ComponentRef,
                         Name = name,
                         Value = value,
-                    });
-
-                    if (null == facade.AssemblyNames)
-                    {
-                        facade.AssemblyNames = new List<MsiAssemblyNameSymbol>();
-                    }
-
-                    facade.AssemblyNames.Add(assemblyNameSymbol);
+                    };
 
+                    facade.AssemblyNameSymbols.Add(assemblyNameSymbol);
                     assemblyNameSymbols.Add(assemblyNameSymbol.Id.Id, assemblyNameSymbol);
                 }
 
-                assemblyNameSymbol.Value = value;
-
                 if (this.VariableCache != null)
                 {
                     var key = String.Format(CultureInfo.InvariantCulture, "assembly{0}.{1}", name, facade.Id).ToLowerInvariant();
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateSymbolsWithFileFacadesCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateSymbolsWithFileFacadesCommand.cs
new file mode 100644
index 00000000..4b332363
--- /dev/null
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateSymbolsWithFileFacadesCommand.cs
@@ -0,0 +1,73 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.WindowsInstaller.Bind
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Symbols;
+    using WixToolset.Extensibility.Data;
+    using WixToolset.Extensibility.Services;
+
+    internal class UpdateSymbolsWithFileFacadesCommand
+    {
+        private readonly IntermediateSection section;
+        private readonly List<IFileFacade> allFileFacades;
+
+        public UpdateSymbolsWithFileFacadesCommand(IntermediateSection section, List<IFileFacade> allFileFacades)
+        {
+            this.section = section;
+            this.allFileFacades = allFileFacades;
+        }
+
+        public void Execute()
+        {
+            var fileSymbolsById = this.section.Symbols.OfType<FileSymbol>().ToDictionary(f => f.Id.Id);
+
+            foreach (var facade in this.allFileFacades)
+            {
+                if (fileSymbolsById.TryGetValue(facade.Id, out var fileSymbol))
+                {
+                    // Only update the file symbol if the facade value changed
+                    if (fileSymbol.DiskId != facade.DiskId)
+                    {
+                        fileSymbol.DiskId = facade.DiskId;
+                    }
+
+                    if (fileSymbol.FileSize != facade.FileSize)
+                    {
+                        fileSymbol.FileSize = facade.FileSize;
+                    }
+
+                    if (fileSymbol.Language != facade.Language)
+                    {
+                        fileSymbol.Language = facade.Language;
+                    }
+
+                    if (fileSymbol.Sequence != facade.Sequence)
+                    {
+                        fileSymbol.Sequence = facade.Sequence;
+                    }
+
+                    if (fileSymbol.Version != facade.Version)
+                    {
+                        fileSymbol.Version = facade.Version;
+                    }
+                }
+
+                if (facade.MsiFileHashSymbol != null)
+                {
+                    this.section.AddSymbol(facade.MsiFileHashSymbol);
+                }
+
+                if (facade.AssemblyNameSymbols != null)
+                {
+                    foreach (var assemblyNameSymbol in facade.AssemblyNameSymbols)
+                    {
+                        this.section.AddSymbol(assemblyNameSymbol);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateTransformsWithFileFacades.cs b/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateTransformsWithFileFacades.cs
index ed865450..7b6c21ef 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateTransformsWithFileFacades.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Bind/UpdateTransformsWithFileFacades.cs
@@ -4,6 +4,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 {
     using System;
     using System.Collections.Generic;
+    using System.IO;
     using System.Linq;
     using WixToolset.Data;
     using WixToolset.Data.Symbols;
@@ -14,10 +15,10 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
     internal class UpdateTransformsWithFileFacades
     {
-        public UpdateTransformsWithFileFacades(IMessaging messaging, WindowsInstallerData output, IEnumerable<SubStorage> subStorages, TableDefinitionCollection tableDefinitions, IEnumerable<IFileFacade> fileFacades)
+        public UpdateTransformsWithFileFacades(IMessaging messaging, IntermediateSection section, IEnumerable<SubStorage> subStorages, TableDefinitionCollection tableDefinitions, IEnumerable<IFileFacade> fileFacades)
         {
             this.Messaging = messaging;
-            this.Output = output;
+            this.Section = section;
             this.SubStorages = subStorages;
             this.TableDefinitions = tableDefinitions;
             this.FileFacades = fileFacades;
@@ -25,7 +26,7 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         private IMessaging Messaging { get; }
 
-        private WindowsInstallerData Output { get; }
+        private IntermediateSection Section { get; }
 
         private IEnumerable<SubStorage> SubStorages { get; }
 
@@ -35,190 +36,97 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
         public void Execute()
         {
-            var fileFacadesByDiskId = new Dictionary<int, Dictionary<string, IFileFacade>>();
-
-            // Index patch file facades by diskId+fileId.
-            foreach (var facade in this.FileFacades)
-            {
-                if (!fileFacadesByDiskId.TryGetValue(facade.DiskId, out var mediaFacades))
-                {
-                    mediaFacades = new Dictionary<string, IFileFacade>();
-                    fileFacadesByDiskId.Add(facade.DiskId, mediaFacades);
-                }
-
-                mediaFacades.Add(facade.Id, facade);
-            }
+            var fileFacadesByDiskId = this.IndexFileFacadesByDiskId();
 
-            var patchMediaRows = new RowDictionary<MediaRow>(this.Output.Tables["Media"]);
+            var mediaSymbolsByDiskId = this.Section.Symbols.OfType<MediaSymbol>().ToDictionary(m => m.DiskId);
 
             // Index paired transforms by name without the "#" prefix.
             var pairedTransforms = this.SubStorages.Where(s => s.Name.StartsWith(PatchConstants.PairedPatchTransformPrefix)).ToDictionary(s => s.Name, s => s.Data);
 
-            // Copy File bind data into substorages
             foreach (var substorage in this.SubStorages.Where(s => !s.Name.StartsWith(PatchConstants.PairedPatchTransformPrefix)))
             {
                 var mainTransform = substorage.Data;
 
-                var mainMsiFileHashIndex = new RowDictionary<Row>(mainTransform.Tables["MsiFileHash"]);
-
                 var pairedTransform = pairedTransforms[PatchConstants.PairedPatchTransformPrefix + substorage.Name];
 
-                // Copy Media.LastSequence.
-                var pairedMediaTable = pairedTransform.Tables["Media"];
-                foreach (MediaRow pairedMediaRow in pairedMediaTable.Rows)
+                // Update the Media.LastSequence in the paired transforms.
+                foreach (var pairedMediaRow in pairedTransform.Tables["Media"].Rows.Cast<MediaRow>())
                 {
-                    var patchMediaRow = patchMediaRows.Get(pairedMediaRow.DiskId);
-                    pairedMediaRow.LastSequence = patchMediaRow.LastSequence;
+                    if (mediaSymbolsByDiskId.TryGetValue(pairedMediaRow.DiskId, out var mediaSymbol) && mediaSymbol.LastSequence.HasValue)
+                    {
+                        pairedMediaRow.LastSequence = mediaSymbol.LastSequence.Value;
+                    }
+                    else // TODO: This shouldn't be possible.
+                    {
+                        throw new InvalidDataException();
+                    }
                 }
 
                 // Validate file row changes for keypath-related issues
                 this.ValidateFileRowChanges(mainTransform);
 
-                // Index File table of pairedTransform
-                var pairedFileRows = new RowDictionary<FileRow>(pairedTransform.Tables["File"]);
-
-                var mainFileTable = mainTransform.Tables["File"];
-                if (null != mainFileTable)
+                // Copy File bind data into transforms
+                if (mainTransform.Tables.TryGetTable("File", out var mainFileTable))
                 {
+                    // Index File table of pairedTransform
+                    var pairedFileRows = new RowDictionary<FileRow>(pairedTransform.Tables["File"]);
+
+                    var mainMsiFileHashIndex = new RowDictionary<Row>(mainTransform.Tables["MsiFileHash"]);
+
                     // Remove the MsiFileHash table because it will be updated later with the final file hash for each file
                     mainTransform.Tables.Remove("MsiFileHash");
 
-                    foreach (FileRow mainFileRow in mainFileTable.Rows)
+                    foreach (var mainFileRow in mainFileTable.Rows.Where(r => r.Operation == RowOperation.Add || r.Operation == RowOperation.Modify).Cast<FileRow>())
                     {
-                        if (RowOperation.Delete == mainFileRow.Operation)
-                        {
-                            continue;
-                        }
-                        else if (RowOperation.None == mainFileRow.Operation)
-                        {
-                            continue;
-                        }
-
-                        // Index patch files by diskId+fileId
+                        // TODO: Wasn't this indexing done at the top of this method?
+                        // Index main transform files by diskId+fileId
                         if (!fileFacadesByDiskId.TryGetValue(mainFileRow.DiskId, out var mediaFacades))
                         {
                             mediaFacades = new Dictionary<string, IFileFacade>();
                             fileFacadesByDiskId.Add(mainFileRow.DiskId, mediaFacades);
                         }
 
-                        // copy data from the patch back to the transform
+                        // Copy data from the facade back to the appropriate transform.
                         if (mediaFacades.TryGetValue(mainFileRow.File, out var facade))
                         {
-                            var patchFileRow = facade.GetFileRow();
                             var pairedFileRow = pairedFileRows.Get(mainFileRow.File);
 
-                            for (var i = 0; i < patchFileRow.Fields.Length; i++)
-                            {
-                                var patchValue = patchFileRow.FieldAsString(i) ?? String.Empty;
-                                var mainValue = mainFileRow.FieldAsString(i) ?? String.Empty;
+                            TryModifyField(mainFileRow, 3, facade.FileSize);
+
+                            TryModifyField(mainFileRow, 4, facade.Version);
+
+                            TryModifyField(mainFileRow, 5, facade.Language);
 
-                                if (1 == i)
-                                {
-                                    // File.Component_ changes should not come from the shared file rows
-                                    // that contain the file information as each individual transform might
-                                    // have different changes (or no changes at all).
-                                }
-                                else if (6 == i) // File.Attributes should not changed for binary deltas
-                                {
-#if TODO_PATCHING_DELTA
-                                    if (null != patchFileRow.Patch)
-                                    {
-                                        // File.Attribute should not change for binary deltas
-                                        pairedFileRow.Attributes = mainFileRow.Attributes;
-                                        mainFileRow.Fields[i].Modified = false;
-                                    }
-#endif
-                                }
-                                else if (7 == i) // File.Sequence is updated in pairedTransform, not mainTransform
-                                {
-                                    // file sequence is updated in Patch table instead of File table for delta patches
 #if TODO_PATCHING_DELTA
-                                    if (null != patchFileRow.Patch)
-                                    {
-                                        pairedFileRow.Fields[i].Modified = false;
-                                    }
-                                    else
+                            // File.Attribute should not change for binary deltas, otherwise copy File Attributes from main transform row.
+                            if (null != facade.Patch)
 #endif
-                                    {
-                                        pairedFileRow[i] = patchFileRow[i];
-                                        pairedFileRow.Fields[i].Modified = true;
-                                    }
-                                    mainFileRow.Fields[i].Modified = false;
-                                }
-                                else if (patchValue != mainValue)
-                                {
-                                    mainFileRow[i] = patchFileRow[i];
-                                    mainFileRow.Fields[i].Modified = true;
-                                    if (mainFileRow.Operation == RowOperation.None)
-                                    {
-                                        mainFileRow.Operation = RowOperation.Modify;
-                                    }
-                                }
+                            {
+                                TryModifyField(pairedFileRow, 6, mainFileRow.Attributes);
+                                mainFileRow.Fields[6].Modified = false;
                             }
 
-                            // Copy MsiFileHash row for this File.
-                            if (!mainMsiFileHashIndex.TryGetValue(patchFileRow.File, out var patchHashRow))
+#if TODO_PATCHING_DELTA
+                            // File.Sequence is updated in Patch table instead of File table for delta patches
+                            if (null != facade.Patch)
                             {
-                                //patchHashRow = patchFileRow.Hash;
-                                throw new NotImplementedException();
+                                pairedFileRow.Fields[7].Modified = false;
                             }
-
-                            if (null != patchHashRow)
+                            else
+#endif
                             {
-                                var mainHashTable = mainTransform.EnsureTable(this.TableDefinitions["MsiFileHash"]);
-                                var mainHashRow = mainHashTable.CreateRow(mainFileRow.SourceLineNumbers);
-                                for (var i = 0; i < patchHashRow.Fields.Length; i++)
-                                {
-                                    mainHashRow[i] = patchHashRow[i];
-                                    if (i > 1)
-                                    {
-                                        // assume all hash fields have been modified
-                                        mainHashRow.Fields[i].Modified = true;
-                                    }
-                                }
-
-                                // assume the MsiFileHash operation follows the File one
-                                mainHashRow.Operation = mainFileRow.Operation;
+                                // File.Sequence is updated in pairedTransform, not mainTransform.
+                                TryModifyField(pairedFileRow, 7, facade.Sequence);
                             }
+                            mainFileRow.Fields[7].Modified = false;
 
-                            // copy MsiAssemblyName rows for this File
-#if TODO_PATCHING
-                            List<Row> patchAssemblyNameRows = patchFileRow.AssemblyNames;
-                            if (null != patchAssemblyNameRows)
-                            {
-                                var mainAssemblyNameTable = mainTransform.EnsureTable(this.TableDefinitions["MsiAssemblyName"]);
-                                foreach (var patchAssemblyNameRow in patchAssemblyNameRows)
-                                {
-                                    // Copy if there isn't an identical modified/added row already in the transform.
-                                    var foundMatchingModifiedRow = false;
-                                    foreach (var mainAssemblyNameRow in mainAssemblyNameTable.Rows)
-                                    {
-                                        if (RowOperation.None != mainAssemblyNameRow.Operation && mainAssemblyNameRow.GetPrimaryKey('/').Equals(patchAssemblyNameRow.GetPrimaryKey('/')))
-                                        {
-                                            foundMatchingModifiedRow = true;
-                                            break;
-                                        }
-                                    }
+                            this.ProcessMsiFileHash(mainTransform, mainFileRow, facade.MsiFileHashSymbol, mainMsiFileHashIndex);
 
-                                    if (!foundMatchingModifiedRow)
-                                    {
-                                        var mainAssemblyNameRow = mainAssemblyNameTable.CreateRow(mainFileRow.SourceLineNumbers);
-                                        for (var i = 0; i < patchAssemblyNameRow.Fields.Length; i++)
-                                        {
-                                            mainAssemblyNameRow[i] = patchAssemblyNameRow[i];
-                                        }
-
-                                        // assume value field has been modified
-                                        mainAssemblyNameRow.Fields[2].Modified = true;
-                                        mainAssemblyNameRow.Operation = mainFileRow.Operation;
-                                    }
-                                }
-                            }
-#endif
+                            this.ProcessMsiAssemblyName(mainTransform, mainFileRow, facade);
 
-                            // Add patch header for this file
 #if TODO_PATCHING_DELTA
-                            if (null != patchFileRow.Patch)
+                            // Add patch header for this file
+                            if (null != facade.Patch)
                             {
                                 // Add the PatchFiles action automatically to the AdminExecuteSequence and InstallExecuteSequence tables.
                                 this.AddPatchFilesActionToSequenceTable(SequenceTable.AdminExecuteSequence, mainTransform, pairedTransform, mainFileRow);
@@ -232,12 +140,12 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                                 }
 
                                 var patchRow = patchTable.CreateRow(mainFileRow.SourceLineNumbers);
-                                patchRow[0] = patchFileRow.File;
-                                patchRow[1] = patchFileRow.Sequence;
+                                patchRow[0] = facade.File;
+                                patchRow[1] = facade.Sequence;
 
-                                var patchFile = new FileInfo(patchFileRow.Source);
+                                var patchFile = new FileInfo(facade.Source);
                                 patchRow[2] = (int)patchFile.Length;
-                                patchRow[3] = 0 == (PatchAttributeType.AllowIgnoreOnError & patchFileRow.PatchAttributes) ? 0 : 1;
+                                patchRow[3] = 0 == (PatchAttributeType.AllowIgnoreOnError & facade.PatchAttributes) ? 0 : 1;
 
                                 var streamName = patchTable.Name + "." + patchRow[0] + "." + patchRow[1];
                                 if (Msi.MsiInterop.MsiMaxStreamNameLength < streamName.Length)
@@ -252,13 +160,13 @@ namespace WixToolset.Core.WindowsInstaller.Bind
 
                                     var patchHeadersRow = patchHeadersTable.CreateRow(mainFileRow.SourceLineNumbers);
                                     patchHeadersRow[0] = streamName;
-                                    patchHeadersRow[1] = patchFileRow.Patch;
+                                    patchHeadersRow[1] = facade.Patch;
                                     patchRow[5] = streamName;
                                     patchHeadersRow.Operation = RowOperation.Add;
                                 }
                                 else
                                 {
-                                    patchRow[4] = patchFileRow.Patch;
+                                    patchRow[4] = facade.Patch;
                                 }
                                 patchRow.Operation = RowOperation.Add;
                             }
@@ -270,14 +178,89 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                         }
                     }
                 }
+            }
+        }
+
+        private void ProcessMsiFileHash(WindowsInstallerData transform, FileRow fileRow, MsiFileHashSymbol msiFileHashSymbol, RowDictionary<Row> msiFileHashIndex)
+        {
+            Row msiFileHashRow = null;
+
+            if (msiFileHashSymbol != null || msiFileHashIndex.TryGetValue(fileRow.File, out msiFileHashRow))
+            {
+                var sourceLineNumbers = msiFileHashSymbol?.SourceLineNumbers ?? msiFileHashRow?.SourceLineNumbers;
+
+                var transformHashTable = transform.EnsureTable(this.TableDefinitions["MsiFileHash"]);
+
+                var transformHashRow = transformHashTable.CreateRow(sourceLineNumbers);
+                transformHashRow.Operation = fileRow.Operation; // Assume the MsiFileHash operation follows the File one.
+
+                transformHashRow[0] = fileRow.File;
+                transformHashRow[1] = msiFileHashSymbol?.Options ?? msiFileHashRow?.Fields[1].Data;
+
+                // Assume all hash fields have been modified.
+                TryModifyField(transformHashRow, 2, msiFileHashSymbol?.HashPart1 ?? msiFileHashRow?.Fields[2].Data);
+                TryModifyField(transformHashRow, 3, msiFileHashSymbol?.HashPart2 ?? msiFileHashRow?.Fields[3].Data);
+                TryModifyField(transformHashRow, 4, msiFileHashSymbol?.HashPart3 ?? msiFileHashRow?.Fields[4].Data);
+                TryModifyField(transformHashRow, 5, msiFileHashSymbol?.HashPart4 ?? msiFileHashRow?.Fields[5].Data);
+            }
+        }
 
-                this.Output.Tables.Remove("Media");
-                this.Output.Tables.Remove("File");
-                this.Output.Tables.Remove("MsiFileHash");
-                this.Output.Tables.Remove("MsiAssemblyName");
+        private void ProcessMsiAssemblyName(WindowsInstallerData transform, FileRow fileRow, IFileFacade facade)
+        {
+            if (facade.AssemblyNameSymbols.Count > 0)
+            {
+                var assemblyNameTable = transform.EnsureTable(this.TableDefinitions["MsiAssemblyName"]);
+
+                foreach (var assemblyNameSymbol in facade.AssemblyNameSymbols)
+                {
+                    // Copy if there isn't an identical modified/added row already in the transform.
+                    var foundMatchingModifiedRow = false;
+                    foreach (var mainAssemblyNameRow in assemblyNameTable.Rows.Where(r => r.Operation != RowOperation.None))
+                    {
+                        var component = mainAssemblyNameRow.FieldAsString(0);
+                        var name = mainAssemblyNameRow.FieldAsString(1);
+
+                        if (assemblyNameSymbol.ComponentRef == component && assemblyNameSymbol.Name == name)
+                        {
+                            foundMatchingModifiedRow = true;
+                            break;
+                        }
+                    }
+
+                    if (!foundMatchingModifiedRow)
+                    {
+                        var assemblyNameRow = assemblyNameTable.CreateRow(fileRow.SourceLineNumbers);
+                        assemblyNameRow[0] = assemblyNameSymbol.ComponentRef;
+                        assemblyNameRow[1] = assemblyNameSymbol.Name;
+                        assemblyNameRow[2] = assemblyNameSymbol.Value;
+
+                        // assume value field has been modified
+                        assemblyNameRow.Fields[2].Modified = true;
+                        assemblyNameRow.Operation = fileRow.Operation;
+                    }
+                }
             }
         }
 
+        private Dictionary<int, Dictionary<string, IFileFacade>> IndexFileFacadesByDiskId()
+        {
+            var fileFacadesByDiskId = new Dictionary<int, Dictionary<string, IFileFacade>>();
+
+            // Index patch file facades by diskId+fileId.
+            foreach (var facade in this.FileFacades)
+            {
+                if (!fileFacadesByDiskId.TryGetValue(facade.DiskId, out var mediaFacades))
+                {
+                    mediaFacades = new Dictionary<string, IFileFacade>();
+                    fileFacadesByDiskId.Add(facade.DiskId, mediaFacades);
+                }
+
+                mediaFacades.Add(facade.Id, facade);
+            }
+
+            return fileFacadesByDiskId;
+        }
+
         /// <summary>
         /// Adds the PatchFiles action to the sequence table if it does not already exist.
         /// </summary>
@@ -349,6 +332,24 @@ namespace WixToolset.Core.WindowsInstaller.Bind
             }
         }
 
+        private static bool TryModifyField(Row row, int index, object value)
+        {
+            var field = row.Fields[index];
+
+            if (field.Data != value)
+            {
+                field.Data = value;
+                field.Modified = true;
+
+                if (row.Operation == RowOperation.None)
+                {
+                    row.Operation = RowOperation.Modify;
+                }
+            }
+
+            return field.Modified;
+        }
+
         /// <summary>
         /// Tests sequence table for PatchFiles and associated actions
         /// </summary>
@@ -396,33 +397,29 @@ namespace WixToolset.Core.WindowsInstaller.Bind
                 return;
             }
 
-            var componentKeyPath = new Dictionary<string, string>(componentTable.Rows.Count);
-
             // Index the Component table for non-directory & non-registry key paths.
-            foreach (var row in componentTable.Rows)
+            var componentKeyPath = new Dictionary<string, string>();
+            foreach (var row in componentTable.Rows.Cast<ComponentRow>().Where(r => !r.IsRegistryKeyPath))
             {
-                var keyPath = row.FieldAsString(5);
-                if (keyPath != null && 0 != (row.FieldAsInteger(3) & WindowsInstallerConstants.MsidbComponentAttributesRegistryKeyPath))
+                var keyPath = row.KeyPath;
+
+                if (!String.IsNullOrEmpty(keyPath))
                 {
-                    componentKeyPath.Add(row.FieldAsString(0), keyPath);
+                    componentKeyPath.Add(row.Component, keyPath);
                 }
             }
 
             var componentWithChangedKeyPath = new Dictionary<string, string>();
             var componentWithNonKeyPathChanged = new Dictionary<string, string>();
+
             // Verify changes in the file table, now that file diffing has occurred
-            foreach (FileRow row in fileTable.Rows)
+            foreach (var row in fileTable.Rows.Cast<FileRow>().Where(r => r.Operation == RowOperation.Modify))
             {
-                if (RowOperation.Modify != row.Operation)
-                {
-                    continue;
-                }
-
-                var fileId = row.FieldAsString(0);
-                var componentId = row.FieldAsString(1);
+                var fileId = row.File;
+                var componentId = row.Component;
 
                 // If this file is the keypath of a component
-                if (componentKeyPath.ContainsValue(fileId))
+                if (componentKeyPath.ContainsValue(componentId))
                 {
                     if (!componentWithChangedKeyPath.ContainsKey(componentId))
                     {
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/TransformSubcommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/TransformSubcommand.cs
index 727e20b2..68cb6554 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/TransformSubcommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/CommandLine/TransformSubcommand.cs
@@ -21,6 +21,7 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
         {
             this.Messaging = serviceProvider.GetService<IMessaging>();
             this.BackendHelper = serviceProvider.GetService<IBackendHelper>();
+            this.PathResolver = serviceProvider.GetService<IPathResolver>();
             this.ExtensionManager = serviceProvider.GetService<IExtensionManager>();
         }
 
@@ -28,6 +29,8 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
 
         private IBackendHelper BackendHelper { get; }
 
+        private IPathResolver PathResolver { get; }
+
         private IExtensionManager ExtensionManager { get; }
 
         private string OutputPath { get; set; }
@@ -40,8 +43,6 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
 
         private string IntermediateFolder { get; set; }
 
-        private bool IsAdminImage { get; set; }
-
         private bool PreserveUnchangedRows { get; set; }
 
         private bool ShowPedanticMessages { get; set; }
@@ -133,10 +134,6 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
                 var parameter = argument.Substring(1);
                 switch (parameter.ToLowerInvariant())
                 {
-                    case "a":
-                        this.IsAdminImage = true;
-                        return true;
-
                     case "intermediatefolder":
                         this.IntermediateFolder = parser.GetNextArgumentAsDirectoryOrError(argument);
                         return true;
@@ -194,15 +191,15 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
                         }
                     }
 
-                    case "val":
+                    case "t":
                     {
-                        var val = parser.GetNextArgumentOrError(argument);
-                        if (String.IsNullOrEmpty(val))
+                        var type = parser.GetNextArgumentOrError(argument);
+                        if (String.IsNullOrEmpty(type))
                         {
                             return true;
                         }
 
-                        switch (val.ToLowerInvariant())
+                        switch (type.ToLowerInvariant())
                         {
                             case "language":
                                 this.ValidationFlags |= TransformFlags.LanguageTransformDefault;
@@ -216,6 +213,22 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
                                 this.ValidationFlags |= TransformFlags.PatchTransformDefault;
                                 return true;
 
+                            default:
+                                parser.ReportErrorArgument(argument, ErrorMessages.IllegalCommandLineArgumentValue(argument, type, new[] { "language", "instance", "patch" }));
+                                return true;
+                        }
+                    }
+
+                    case "val":
+                    {
+                        var val = parser.GetNextArgumentOrError(argument);
+                        if (String.IsNullOrEmpty(val))
+                        {
+                            return true;
+                        }
+
+                        switch (val.ToLowerInvariant())
+                        {
                             case "g":
                                 this.ValidationFlags |= TransformFlags.ValidateUpgradeCode;
                                 return true;
@@ -261,7 +274,7 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
                                 return true;
 
                             default:
-                                parser.ReportErrorArgument(argument, ErrorMessages.IllegalCommandLineArgumentValue(argument, val, new[] { "language", "instance", "patch", "g", "l", "r", "s", "t", "u", "v", "w", "x", "y", "z" }));
+                                parser.ReportErrorArgument(argument, ErrorMessages.IllegalCommandLineArgumentValue(argument, val, new[] { "g", "l", "r", "s", "t", "u", "v", "w", "x", "y", "z" }));
                                 return true;
                         }
                     }
@@ -297,7 +310,7 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
             {
                 Exception exception;
 
-                (transform, exception) = LoadWindowsInstallerDataSafely(this.TargetPath);
+                (transform, exception) = DataLoader.LoadWindowsInstallerDataSafely(this.TargetPath);
 
                 if (transform?.Type != OutputType.Transform)
                 {
@@ -340,17 +353,9 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
 
         private WindowsInstallerData CreateTransform()
         {
-            if (!TryLoadWindowsInstallerData(this.TargetPath, out var targetOutput))
-            {
-                var unbindCommand = new UnbindMsiOrMsmCommand(this.Messaging, this.BackendHelper, this.TargetPath, this.ExportBasePath, this.IntermediateFolder, this.IsAdminImage, suppressDemodularization: true, suppressExtractCabinets: true);
-                targetOutput = unbindCommand.Execute();
-            }
+            var targetData = this.GetWindowsInstallerData(this.TargetPath);
 
-            if (!TryLoadWindowsInstallerData(this.TargetPath, out var updatedOutput))
-            {
-                var unbindCommand = new UnbindMsiOrMsmCommand(this.Messaging, this.BackendHelper, this.UpdatedPath, this.ExportBasePath, this.IntermediateFolder, this.IsAdminImage, suppressDemodularization: true, suppressExtractCabinets: true);
-                updatedOutput = unbindCommand.Execute();
-            }
+            var updatedData = this.GetWindowsInstallerData(this.UpdatedPath);
 
             var differ = new Differ(this.Messaging)
             {
@@ -359,7 +364,7 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
                 SuppressKeepingSpecialRows = this.SuppressKeepingSpecialRows
             };
 
-            return differ.Diff(targetOutput, updatedOutput, this.ValidationFlags);
+            return differ.Diff(targetData, updatedData, this.ValidationFlags);
         }
 
         private TableDefinitionCollection GetTableDefinitions()
@@ -370,37 +375,15 @@ namespace WixToolset.Core.WindowsInstaller.CommandLine
             return loadTableDefinitions.Execute();
         }
 
-        private static bool TryLoadWindowsInstallerData(string path, out WindowsInstallerData data)
+        private WindowsInstallerData GetWindowsInstallerData(string path)
         {
-            data = null;
-
-            var extension = Path.GetExtension(path);
-
-            // If the path is _not_ obviously a Windows Installer database, let's try opening it as
-            // our own data file format.
-            if (!extension.Equals(".msi", StringComparison.OrdinalIgnoreCase) && !extension.Equals(".msm", StringComparison.OrdinalIgnoreCase))
-            {
-                (data, _) = LoadWindowsInstallerDataSafely(path);
-            }
-
-            return data != null;
-        }
-
-        private static (WindowsInstallerData, Exception) LoadWindowsInstallerDataSafely(string path)
-        {
-            WindowsInstallerData data = null;
-            Exception exception = null;
-
-            try
-            {
-                data = WindowsInstallerData.Load(path);
-            }
-            catch (Exception e)
+            if (!DataLoader.TryLoadWindowsInstallerData(path, out var data))
             {
-                exception = e;
+                var unbindCommand = new UnbindDatabaseCommand(this.Messaging, this.BackendHelper, this.PathResolver, path, OutputType.Product, this.ExportBasePath, null, this.IntermediateFolder, enableDemodularization: false, skipSummaryInfo: false);
+                data = unbindCommand.Execute();
             }
 
-            return (data, exception);
+            return data;
         }
     }
 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Differ.cs b/src/wix/WixToolset.Core.WindowsInstaller/Differ.cs
index ae9492eb..f4e4a1fc 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Differ.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Differ.cs
@@ -10,7 +10,6 @@ namespace WixToolset.Core.WindowsInstaller
     using WixToolset.Data;
     using WixToolset.Data.Symbols;
     using WixToolset.Data.WindowsInstaller;
-    using WixToolset.Extensibility;
     using WixToolset.Extensibility.Services;
 
     /// <summary>
@@ -18,7 +17,7 @@ namespace WixToolset.Core.WindowsInstaller
     /// </summary>
     public sealed class Differ
     {
-        private const char sectionDelimiter = '/';
+        private const char SectionDelimiter = '/';
         private readonly IMessaging messaging;
         private SummaryInformationStreams transformSummaryInfo;
 
@@ -53,24 +52,16 @@ namespace WixToolset.Core.WindowsInstaller
         /// </summary>
         /// <param name="targetOutput">The target output.</param>
         /// <param name="updatedOutput">The updated output.</param>
-        /// <returns>The transform.</returns>
-        public WindowsInstallerData Diff(WindowsInstallerData targetOutput, WindowsInstallerData updatedOutput)
-        {
-            return this.Diff(targetOutput, updatedOutput, 0);
-        }
-
-        /// <summary>
-        /// Creates a transform by diffing two outputs.
-        /// </summary>
-        /// <param name="targetOutput">The target output.</param>
-        /// <param name="updatedOutput">The updated output.</param>
         /// <param name="validationFlags"></param>
         /// <returns>The transform.</returns>
         public WindowsInstallerData Diff(WindowsInstallerData targetOutput, WindowsInstallerData updatedOutput, TransformFlags validationFlags)
         {
-            var transform = new WindowsInstallerData(null);
-            transform.Type = OutputType.Transform;
-            transform.Codepage = updatedOutput.Codepage;
+            var transform = new WindowsInstallerData(null)
+            {
+                Type = OutputType.Transform,
+                Codepage = updatedOutput.Codepage
+            };
+
             this.transformSummaryInfo = new SummaryInformationStreams();
 
             // compare the codepages
@@ -120,7 +111,7 @@ namespace WixToolset.Core.WindowsInstaller
                     foreach (var updatedRow in updatedTable.Rows)
                     {
                         updatedRow.Operation = RowOperation.Add;
-                        updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId;
+                        updatedRow.SectionId = SectionDelimiter + updatedRow.SectionId;
                         addedTable.Rows.Add(updatedRow);
                     }
                 }
@@ -209,7 +200,7 @@ namespace WixToolset.Core.WindowsInstaller
                 else if (null == updatedRow)
                 {
                     operation = targetRow.Operation = RowOperation.Delete;
-                    targetRow.SectionId += sectionDelimiter;
+                    targetRow.SectionId += SectionDelimiter;
                     comparedRow = targetRow;
                     keepRow = true;
                 }
@@ -222,7 +213,7 @@ namespace WixToolset.Core.WindowsInstaller
                     // ignore rows that shouldn't be in a transform
                     if (Enum.IsDefined(typeof(SummaryInformation.Transform), (int)updatedRow[0]))
                     {
-                        updatedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
+                        updatedRow.SectionId = targetRow.SectionId + SectionDelimiter + updatedRow.SectionId;
                         comparedRow = updatedRow;
                         keepRow = true;
                         operation = RowOperation.Modify;
@@ -306,7 +297,7 @@ namespace WixToolset.Core.WindowsInstaller
                     if (keepRow)
                     {
                         comparedRow = updatedRow;
-                        comparedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
+                        comparedRow.SectionId = targetRow.SectionId + SectionDelimiter + updatedRow.SectionId;
                     }
                 }
             }
@@ -350,8 +341,9 @@ namespace WixToolset.Core.WindowsInstaller
                     // diff the target and updated rows
                     foreach (var targetPrimaryKeyEntry in targetPrimaryKeys)
                     {
-                        var targetPrimaryKey = targetPrimaryKeyEntry.Key;
-                        var compared = this.CompareRows(targetTable, targetPrimaryKeyEntry.Value, updatedPrimaryKeys[targetPrimaryKey], out var _, out var keepRow);
+                        updatedPrimaryKeys.TryGetValue(targetPrimaryKeyEntry.Key, out var updatedRow);
+
+                        var compared = this.CompareRows(targetTable, targetPrimaryKeyEntry.Value, updatedRow, out var _, out var keepRow);
 
                         if (keepRow)
                         {
@@ -369,7 +361,7 @@ namespace WixToolset.Core.WindowsInstaller
                             var updatedRow = (Row)updatedPrimaryKeyEntry.Value;
 
                             updatedRow.Operation = RowOperation.Add;
-                            updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId;
+                            updatedRow.SectionId = SectionDelimiter + updatedRow.SectionId;
                             rows.Add(updatedRow);
                         }
                     }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/ExtensibilityServices/FileFacade.cs b/src/wix/WixToolset.Core.WindowsInstaller/ExtensibilityServices/FileFacade.cs
new file mode 100644
index 00000000..eede6e24
--- /dev/null
+++ b/src/wix/WixToolset.Core.WindowsInstaller/ExtensibilityServices/FileFacade.cs
@@ -0,0 +1,82 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Core.WindowsInstaller.ExtensibilityServices
+{
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Data.Symbols;
+    using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Data.WindowsInstaller.Rows;
+    using WixToolset.Extensibility.Data;
+
+    internal class FileFacade : IFileFacade
+    {
+        public FileFacade(FileSymbol file)
+        {
+            this.Identifier = file.Id;
+            this.ComponentRef = file.ComponentRef;
+            this.DiskId = file.DiskId ?? 1;
+            this.FileName = file.Name;
+            this.FileSize = file.FileSize;
+            this.Language = file.Language;
+            this.PatchGroup = file.PatchGroup;
+            this.Sequence = file.Sequence;
+            this.SourceLineNumber = file.SourceLineNumbers;
+            this.SourcePath = file.Source?.Path;
+            this.Compressed = (file.Attributes & FileSymbolAttributes.Compressed) == FileSymbolAttributes.Compressed;
+            this.Uncompressed = (file.Attributes & FileSymbolAttributes.Uncompressed) == FileSymbolAttributes.Uncompressed;
+            this.Version = file.Version;
+            this.AssemblyNameSymbols = new List<MsiAssemblyNameSymbol>();
+        }
+
+        public FileFacade(FileRow row)
+        {
+            this.Identifier = new Identifier(AccessModifier.Section, row.File);
+            this.ComponentRef = row.Component;
+            this.DiskId = row.DiskId;
+            this.FileName = row.FileName;
+            this.FileSize = row.FileSize;
+            this.Language = row.Language;
+            this.PatchGroup = null;
+            this.Sequence = row.Sequence;
+            this.SourceLineNumber = row.SourceLineNumbers;
+            this.SourcePath = row.Source;
+            this.Compressed = (row.Attributes & WindowsInstallerConstants.MsidbFileAttributesCompressed) == WindowsInstallerConstants.MsidbFileAttributesCompressed;
+            this.Uncompressed = (row.Attributes & WindowsInstallerConstants.MsidbFileAttributesNoncompressed) == WindowsInstallerConstants.MsidbFileAttributesNoncompressed;
+            this.Version = row.Version;
+            this.AssemblyNameSymbols = new List<MsiAssemblyNameSymbol>();
+        }
+
+        public string Id => this.Identifier.Id;
+
+        public Identifier Identifier { get; }
+
+        public string ComponentRef { get; }
+
+        public int DiskId { get; set; }
+
+        public string FileName { get; }
+
+        public int FileSize { get; set; }
+
+        public string Language { get; set; }
+
+        public int? PatchGroup { get; }
+
+        public int Sequence { get; set; }
+
+        public SourceLineNumber SourceLineNumber { get; }
+
+        public string SourcePath { get; }
+
+        public bool Compressed { get; }
+
+        public bool Uncompressed { get; }
+
+        public string Version { get; set; }
+
+        public MsiFileHashSymbol MsiFileHashSymbol { get; set; }
+
+        public ICollection<MsiAssemblyNameSymbol> AssemblyNameSymbols { get; }
+    }
+}
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/ExtensibilityServices/WindowsInstallerBackendHelper.cs b/src/wix/WixToolset.Core.WindowsInstaller/ExtensibilityServices/WindowsInstallerBackendHelper.cs
index ad738321..f372af82 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/ExtensibilityServices/WindowsInstallerBackendHelper.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/ExtensibilityServices/WindowsInstallerBackendHelper.cs
@@ -23,19 +23,14 @@ namespace WixToolset.Core.WindowsInstaller.ExtensibilityServices
 
         #region IBackendHelper interfaces
 
-        public IFileFacade CreateFileFacade(FileSymbol file, AssemblySymbol assembly)
+        public IFileFacade CreateFileFacade(FileSymbol file)
         {
-            return this.backendHelper.CreateFileFacade(file, assembly);
+            return new FileFacade(file);
         }
 
         public IFileFacade CreateFileFacade(FileRow fileRow)
         {
-            return this.backendHelper.CreateFileFacade(fileRow);
-        }
-
-        public IFileFacade CreateFileFacadeFromMergeModule(FileSymbol fileSymbol)
-        {
-            return this.backendHelper.CreateFileFacadeFromMergeModule(fileSymbol);
+            return new FileFacade(fileRow);
         }
 
         public IFileTransfer CreateFileTransfer(string source, string destination, bool move, SourceLineNumber sourceLineNumbers = null)
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/MsiBackend.cs b/src/wix/WixToolset.Core.WindowsInstaller/MsiBackend.cs
index f73791aa..27bb282b 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/MsiBackend.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/MsiBackend.cs
@@ -2,11 +2,7 @@
 
 namespace WixToolset.Core.WindowsInstaller
 {
-    using System;
     using WixToolset.Core.WindowsInstaller.Bind;
-    using WixToolset.Core.WindowsInstaller.Decompile;
-    using WixToolset.Core.WindowsInstaller.Unbind;
-    using WixToolset.Data;
     using WixToolset.Extensibility;
     using WixToolset.Extensibility.Data;
     using WixToolset.Extensibility.Services;
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/MspBackend.cs b/src/wix/WixToolset.Core.WindowsInstaller/MspBackend.cs
index 38a4ab34..bccdd3d4 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/MspBackend.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/MspBackend.cs
@@ -2,7 +2,6 @@
 
 namespace WixToolset.Core.WindowsInstaller
 {
-    using System;
     using System.Collections.Generic;
     using WixToolset.Core.WindowsInstaller.Bind;
     using WixToolset.Data.WindowsInstaller;
@@ -18,8 +17,14 @@ namespace WixToolset.Core.WindowsInstaller
 
             var backendHelper = context.ServiceProvider.GetService<IBackendHelper>();
 
+            var pathResolver = context.ServiceProvider.GetService<IPathResolver>();
+
+            var fileResolver = context.ServiceProvider.GetService<IFileResolver>();
+
             var extensionManager = context.ServiceProvider.GetService<IExtensionManager>();
 
+            var resolveExtensions = extensionManager.GetServices<IResolverExtension>();
+
             var backendExtensions = extensionManager.GetServices<IWindowsInstallerBackendBinderExtension>();
 
             foreach (var extension in backendExtensions)
@@ -30,7 +35,7 @@ namespace WixToolset.Core.WindowsInstaller
             // Create transforms named in patch transforms.
             IEnumerable<PatchTransform> patchTransforms;
             {
-                var command = new CreatePatchTransformsCommand(messaging, backendHelper, context.IntermediateRepresentation, context.IntermediateFolder);
+                var command = new CreatePatchTransformsCommand(messaging, backendHelper, pathResolver, fileResolver, resolveExtensions, context.IntermediateRepresentation, context.IntermediateFolder, context.BindPaths);
                 patchTransforms = command.Execute();
             }
 
@@ -42,7 +47,7 @@ namespace WixToolset.Core.WindowsInstaller
             }
 
             // Create WindowsInstallerData with patch metdata and transforms as sub-storages
-            // Create MSP from WindowsInstallerData
+            // and create MSP from that WindowsInstallerData.
             IBindResult result = null;
             try
             {
@@ -62,90 +67,5 @@ namespace WixToolset.Core.WindowsInstaller
                 throw;
             }
         }
-
-#if TODO_PATCHING
-        public Intermediate Unbind(IUnbindContext context)
-        {
-            Output patch;
-
-            // patch files are essentially database files (use a special flag to let the API know its a patch file)
-            try
-            {
-                using (Database database = new Database(context.InputFilePath, OpenDatabase.ReadOnly | OpenDatabase.OpenPatchFile))
-                {
-                    var unbindCommand = new UnbindDatabaseCommand(context.Messaging, database, context.InputFilePath, OutputType.Patch, context.ExportBasePath, context.IntermediateFolder, context.IsAdminImage, context.SuppressDemodularization, skipSummaryInfo: false);
-                    patch = unbindCommand.Execute();
-                }
-            }
-            catch (Win32Exception e)
-            {
-                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
-                {
-                    throw new WixException(WixErrors.OpenDatabaseFailed(context.InputFilePath));
-                }
-
-                throw;
-            }
-
-            // retrieve the transforms (they are in substorages)
-            using (Storage storage = Storage.Open(context.InputFilePath, StorageMode.Read | StorageMode.ShareDenyWrite))
-            {
-                Table summaryInformationTable = patch.Tables["_SummaryInformation"];
-                foreach (Row row in summaryInformationTable.Rows)
-                {
-                    if (8 == (int)row[0]) // PID_LASTAUTHOR
-                    {
-                        string value = (string)row[1];
-
-                        foreach (string decoratedSubStorageName in value.Split(';'))
-                        {
-                            string subStorageName = decoratedSubStorageName.Substring(1);
-                            string transformFile = Path.Combine(context.IntermediateFolder, String.Concat("Transform", Path.DirectorySeparatorChar, subStorageName, ".mst"));
-
-                            // ensure the parent directory exists
-                            Directory.CreateDirectory(Path.GetDirectoryName(transformFile));
-
-                            // copy the substorage to a new storage for the transform file
-                            using (Storage subStorage = storage.OpenStorage(subStorageName))
-                            {
-                                using (Storage transformStorage = Storage.CreateDocFile(transformFile, StorageMode.ReadWrite | StorageMode.ShareExclusive | StorageMode.Create))
-                                {
-                                    subStorage.CopyTo(transformStorage);
-                                }
-                            }
-
-                            // unbind the transform
-                            var unbindCommand= new UnbindTransformCommand(context.Messaging, transformFile, (null == context.ExportBasePath ? null : Path.Combine(context.ExportBasePath, subStorageName)), context.IntermediateFolder);
-                            var transform = unbindCommand.Execute();
-
-                            patch.SubStorages.Add(new SubStorage(subStorageName, transform));
-                        }
-
-                        break;
-                    }
-                }
-            }
-
-            // extract the files from the cabinets
-            // TODO: use per-transform export paths for support of multi-product patches
-            if (null != context.ExportBasePath && !context.SuppressExtractCabinets)
-            {
-                using (Database database = new Database(context.InputFilePath, OpenDatabase.ReadOnly | OpenDatabase.OpenPatchFile))
-                {
-                    foreach (SubStorage subStorage in patch.SubStorages)
-                    {
-                        // only patch transforms should carry files
-                        if (subStorage.Name.StartsWith("#", StringComparison.Ordinal))
-                        {
-                            var extractCommand = new ExtractCabinetsCommand(subStorage.Data, database, context.InputFilePath, context.ExportBasePath, context.IntermediateFolder);
-                            extractCommand.Execute();
-                        }
-                    }
-                }
-            }
-
-            return patch;
-        }
-#endif
     }
 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Unbind/ExtractCabinetsCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Unbind/ExtractCabinetsCommand.cs
index 8f52bed9..9aa6f3d4 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Unbind/ExtractCabinetsCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Unbind/ExtractCabinetsCommand.cs
@@ -3,7 +3,6 @@
 namespace WixToolset.Core.WindowsInstaller.Unbind
 {
     using System;
-    using System.Collections;
     using System.Collections.Generic;
     using System.Globalization;
     using System.IO;
@@ -26,7 +25,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
             this.TreatOutputAsModule = treatOutputAsModule;
         }
 
-        public string[] ExtractedFiles { get; private set; }
+        public Dictionary<string, MediaRow> ExtractedFileIdsWithMediaRow { get; private set; }
 
         private WindowsInstallerData Output { get; }
 
@@ -42,47 +41,51 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
 
         public void Execute()
         {
+            var extractedFileIdsWithMediaRow = new Dictionary<string, MediaRow>();
             var databaseBasePath = Path.GetDirectoryName(this.InputFilePath);
-            var cabinetFiles = new List<string>();
-            var embeddedCabinets = new SortedList();
+
+            var cabinetPathsWithMediaRow = new Dictionary<string, MediaRow>();
+            var embeddedCabinetNamesByDiskId = new SortedDictionary<int, string>();
+            var embeddedCabinetRowsByDiskId = new SortedDictionary<int, MediaRow>();
 
             // index all of the cabinet files
             if (OutputType.Module == this.Output.Type || this.TreatOutputAsModule)
             {
-                embeddedCabinets.Add(0, "MergeModule.CABinet");
+                embeddedCabinetNamesByDiskId.Add(0, "MergeModule.CABinet");
             }
-            else if (null != this.Output.Tables["Media"])
+            else if (this.Output.Tables.TryGetTable("Media", out var mediaTable))
             {
-                foreach (MediaRow mediaRow in this.Output.Tables["Media"].Rows)
+                foreach (var mediaRow in mediaTable.Rows.Cast<MediaRow>().Where(r => !String.IsNullOrEmpty(r.Cabinet)))
                 {
-                    if (null != mediaRow.Cabinet)
+                    if (OutputType.Product == this.Output.Type ||
+                        (OutputType.Transform == this.Output.Type && RowOperation.Add == mediaRow.Operation))
                     {
-                        if (OutputType.Product == this.Output.Type ||
-                            (OutputType.Transform == this.Output.Type && RowOperation.Add == mediaRow.Operation))
+                        if (mediaRow.Cabinet.StartsWith("#", StringComparison.Ordinal))
                         {
-                            if (mediaRow.Cabinet.StartsWith("#", StringComparison.Ordinal))
-                            {
-                                embeddedCabinets.Add(mediaRow.DiskId, mediaRow.Cabinet.Substring(1));
-                            }
-                            else
-                            {
-                                cabinetFiles.Add(Path.Combine(databaseBasePath, mediaRow.Cabinet));
-                            }
+                            embeddedCabinetNamesByDiskId.Add(mediaRow.DiskId, mediaRow.Cabinet.Substring(1));
+                            embeddedCabinetRowsByDiskId.Add(mediaRow.DiskId, mediaRow);
+                        }
+                        else
+                        {
+                            cabinetPathsWithMediaRow.Add(Path.Combine(databaseBasePath, mediaRow.Cabinet), mediaRow);
                         }
                     }
                 }
             }
 
-            // extract the embedded cabinet files from the database
-            if (0 < embeddedCabinets.Count)
+            // Extract any embedded cabinet files from the database.
+            if (0 < embeddedCabinetRowsByDiskId.Count)
             {
                 using (var streamsView = this.Database.OpenView("SELECT `Data` FROM `_Streams` WHERE `Name` = ?"))
                 {
-                    foreach (int diskId in embeddedCabinets.Keys)
+                    foreach (var diskIdWithCabinetName in embeddedCabinetNamesByDiskId)
                     {
+                        var diskId = diskIdWithCabinetName.Key;
+                        var cabinetName = diskIdWithCabinetName.Value;
+
                         using (var record = new Record(1))
                         {
-                            record.SetString(1, (string)embeddedCabinets[diskId]);
+                            record.SetString(1, cabinetName);
                             streamsView.Execute(record);
                         }
 
@@ -92,15 +95,15 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                             {
                                 // since the cabinets are stored in case-sensitive streams inside the msi, but the file system is not (typically) case-sensitive,
                                 // embedded cabinets must be extracted to a canonical file name (like their diskid) to ensure extraction will always work
-                                var cabinetFile = Path.Combine(this.IntermediateFolder, String.Concat("Media", Path.DirectorySeparatorChar, diskId.ToString(CultureInfo.InvariantCulture), ".cab"));
+                                var cabinetPath = Path.Combine(this.IntermediateFolder, "Media", diskId.ToString(CultureInfo.InvariantCulture), ".cab");
 
                                 // ensure the parent directory exists
-                                Directory.CreateDirectory(Path.GetDirectoryName(cabinetFile));
+                                Directory.CreateDirectory(Path.GetDirectoryName(cabinetPath));
 
-                                using (var fs = File.Create(cabinetFile))
+                                using (var fs = File.Create(cabinetPath))
                                 {
                                     int bytesRead;
-                                    var buffer = new byte[512];
+                                    var buffer = new byte[4096];
 
                                     while (0 != (bytesRead = record.GetStream(1, buffer, buffer.Length)))
                                     {
@@ -108,7 +111,8 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                                     }
                                 }
 
-                                cabinetFiles.Add(cabinetFile);
+                                embeddedCabinetRowsByDiskId.TryGetValue(diskId, out var cabinetMediaRow);
+                                cabinetPathsWithMediaRow.Add(cabinetPath, cabinetMediaRow);
                             }
                             else
                             {
@@ -119,29 +123,34 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                 }
             }
 
-            // extract the cabinet files
-            if (0 < cabinetFiles.Count)
+            // Extract files from any available cabinets.
+            if (0 < cabinetPathsWithMediaRow.Count)
             {
-                // ensure the directory exists or extraction will fail
                 Directory.CreateDirectory(this.ExportBasePath);
 
-                foreach (var cabinetFile in cabinetFiles)
+                foreach (var cabinetPathWithMediaRow in cabinetPathsWithMediaRow)
                 {
+                    var cabinetPath = cabinetPathWithMediaRow.Key;
+                    var cabinetMediaRow = cabinetPathWithMediaRow.Value;
+
                     try
                     {
-                        var cabinet = new Cabinet(cabinetFile);
-                        this.ExtractedFiles = cabinet.Extract(this.ExportBasePath).ToArray();
+                        var cabinet = new Cabinet(cabinetPath);
+                        var cabinetFilesExtracted = cabinet.Extract(this.ExportBasePath);
+
+                        foreach (var extractedFile in cabinetFilesExtracted)
+                        {
+                            extractedFileIdsWithMediaRow.Add(extractedFile, cabinetMediaRow);
+                        }
                     }
                     catch (FileNotFoundException)
                     {
-                        throw new WixException(ErrorMessages.FileNotFound(new SourceLineNumber(this.InputFilePath), cabinetFile));
+                        throw new WixException(ErrorMessages.FileNotFound(new SourceLineNumber(this.InputFilePath), cabinetPath));
                     }
                 }
             }
-            else
-            {
-                this.ExtractedFiles = new string[0];
-            }
+
+            this.ExtractedFileIdsWithMediaRow = extractedFileIdsWithMediaRow;
         }
     }
 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindDatabaseCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindDatabaseCommand.cs
index c1fb7f12..7bbbbd76 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindDatabaseCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindDatabaseCommand.cs
@@ -5,29 +5,35 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
     using System;
     using System.Collections;
     using System.Collections.Generic;
+    using System.ComponentModel;
     using System.Globalization;
     using System.IO;
+    using System.Linq;
     using System.Text.RegularExpressions;
     using WixToolset.Core.Native.Msi;
     using WixToolset.Data;
     using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Data.WindowsInstaller.Rows;
+    using WixToolset.Extensibility.Data;
     using WixToolset.Extensibility.Services;
 
     internal class UnbindDatabaseCommand
     {
-        private List<string> exportedFiles;
+        private static readonly Regex Modularization = new Regex(@"\.[0-9A-Fa-f]{8}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{12}");
 
-        public UnbindDatabaseCommand(IMessaging messaging, IBackendHelper backendHelper, Database database, string databasePath, OutputType outputType, string exportBasePath, string intermediateFolder, bool isAdminImage, bool suppressDemodularization, bool skipSummaryInfo)
+        private int sectionCount;
+
+        public UnbindDatabaseCommand(IMessaging messaging, IBackendHelper backendHelper, IPathResolver pathResolver, string databasePath, OutputType outputType, string exportBasePath, string extractFilesFolder, string intermediateFolder, bool enableDemodularization, bool skipSummaryInfo)
         {
             this.Messaging = messaging;
             this.BackendHelper = backendHelper;
-            this.Database = database;
+            this.PathResolver = pathResolver;
             this.DatabasePath = databasePath;
             this.OutputType = outputType;
             this.ExportBasePath = exportBasePath;
+            this.ExtractFilesFolder = extractFilesFolder;
             this.IntermediateFolder = intermediateFolder;
-            this.IsAdminImage = isAdminImage;
-            this.SuppressDemodularization = suppressDemodularization;
+            this.EnableDemodularization = enableDemodularization;
             this.SkipSummaryInfo = skipSummaryInfo;
 
             this.TableDefinitions = new TableDefinitionCollection(WindowsInstallerTableDefinitions.All);
@@ -37,7 +43,9 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
 
         public IBackendHelper BackendHelper { get; }
 
-        public Database Database { get; }
+        private IPathResolver PathResolver { get; }
+
+        private Database Database { get; set; }
 
         public string DatabasePath { get; }
 
@@ -45,73 +53,91 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
 
         public string ExportBasePath { get; }
 
-        public string IntermediateFolder { get; }
+        public string ExtractFilesFolder { get; }
 
-        public bool IsAdminImage { get; }
+        public string IntermediateFolder { get; }
 
-        public bool SuppressDemodularization { get; }
+        public bool EnableDemodularization { get; }
 
         public bool SkipSummaryInfo { get; }
 
         public TableDefinitionCollection TableDefinitions { get; }
 
-        public IEnumerable<string> ExportedFiles => this.exportedFiles;
+        public bool AdminImage { get; private set; }
 
-        private int SectionCount { get; set; }
+        public IEnumerable<string> ExportedFiles { get; private set; }
 
         public WindowsInstallerData Execute()
         {
-            this.exportedFiles = new List<string>();
+            var adminImage = false;
+            var exportedFiles = new List<string>();
 
-            string modularizationGuid = null;
-            var output = new WindowsInstallerData(new SourceLineNumber(this.DatabasePath));
-            View validationView = null;
+            var output = new WindowsInstallerData(new SourceLineNumber(this.DatabasePath))
+            {
+                Type = this.OutputType
+            };
+
+            try
+            {
+                using (var database = new Database(this.DatabasePath, OpenDatabase.ReadOnly))
+                {
+                    this.Database = database;
 
-            // set the output type
-            output.Type = this.OutputType;
+                    Directory.CreateDirectory(this.IntermediateFolder);
 
-            Directory.CreateDirectory(this.IntermediateFolder);
+                    output.Codepage = this.GetCodePage();
 
-            // get the codepage
-            this.Database.Export("_ForceCodepage", this.IntermediateFolder, "_ForceCodepage.idt");
-            using (var sr = File.OpenText(Path.Combine(this.IntermediateFolder, "_ForceCodepage.idt")))
-            {
-                string line;
+                    var modularizationGuid = this.ProcessTables(output, exportedFiles);
 
-                while (null != (line = sr.ReadLine()))
-                {
-                    var data = line.Split('\t');
+                    var summaryInfo = this.ProcessSummaryInfo(output, modularizationGuid);
 
-                    if (2 == data.Length)
-                    {
-                        output.Codepage = Convert.ToInt32(data[0], CultureInfo.InvariantCulture);
-                    }
+                    this.UpdateUnrealFileColumns(this.DatabasePath, output, summaryInfo, exportedFiles);
+
+                    this.GenerateSectionIds(output);
                 }
             }
-
-            // get the summary information table if it exists; it won't if unbinding a transform
-            if (!this.SkipSummaryInfo)
+            catch (Win32Exception e)
             {
-                using (var summaryInformation = new SummaryInformation(this.Database))
+                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
                 {
-                    var table = new Table(this.TableDefinitions["_SummaryInformation"]);
+                    throw new WixException(ErrorMessages.OpenDatabaseFailed(this.DatabasePath));
+                }
 
-                    for (var i = 1; 19 >= i; i++)
-                    {
-                        var value = summaryInformation.GetProperty(i);
+                throw;
+            }
 
-                        if (0 < value.Length)
-                        {
-                            var row = table.CreateRow(output.SourceLineNumbers);
-                            row[0] = i;
-                            row[1] = value;
-                        }
-                    }
+            this.AdminImage = adminImage;
+            this.ExportedFiles = exportedFiles;
 
-                    output.Tables.Add(table);
+            return output;
+        }
+
+        private int GetCodePage()
+        {
+            var codepage = 0;
+
+            this.Database.Export("_ForceCodepage", this.IntermediateFolder, "_ForceCodepage.idt");
+
+            var lines = File.ReadAllLines(Path.Combine(this.IntermediateFolder, "_ForceCodepage.idt"));
+
+            if (lines.Length == 3)
+            {
+                var data = lines[2].Split('\t');
+
+                if (2 == data.Length)
+                {
+                    codepage = Convert.ToInt32(data[0], CultureInfo.InvariantCulture);
                 }
             }
 
+            return codepage;
+        }
+
+        private string ProcessTables(WindowsInstallerData output, List<string> exportedFiles)
+        {
+            View validationView = null;
+            string modularizationGuid = null;
+
             try
             {
                 // open a view on the validation table if it exists
@@ -127,7 +153,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                     {
                         var tableName = tableRecord.GetString(1);
 
-                        using (var tableView = this.Database.OpenExecuteView(String.Format(CultureInfo.InvariantCulture, "SELECT * FROM `{0}`", tableName)))
+                        using (var tableView = this.Database.OpenExecuteView($"SELECT * FROM `{tableName}`"))
                         {
                             var tableDefinition = this.GetTableDefinition(tableName, tableView, validationView);
                             var table = new Table(tableDefinition);
@@ -154,16 +180,8 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                                         switch (row.Fields[i].Column.Type)
                                         {
                                             case ColumnType.Number:
-                                                var success = false;
                                                 var intValue = rowRecord.GetInteger(i + 1);
-                                                if (row.Fields[i].Column.IsLocalizable)
-                                                {
-                                                    success = row.BestEffortSetField(i, Convert.ToString(intValue, CultureInfo.InvariantCulture));
-                                                }
-                                                else
-                                                {
-                                                    success = row.BestEffortSetField(i, intValue);
-                                                }
+                                                var success = row.Fields[i].Column.IsLocalizable ? row.BestEffortSetField(i, Convert.ToString(intValue, CultureInfo.InvariantCulture)) : row.BestEffortSetField(i, intValue);
 
                                                 if (!success)
                                                 {
@@ -171,20 +189,18 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                                                 }
                                                 break;
                                             case ColumnType.Object:
-                                                var sourceFile = "FILE NOT EXPORTED";
+                                                var source = "FILE NOT EXPORTED";
 
                                                 if (null != this.ExportBasePath)
                                                 {
-                                                    var relativeSourceFile = Path.Combine(tableName, row.GetPrimaryKey('.'));
-                                                    sourceFile = Path.Combine(this.ExportBasePath, relativeSourceFile);
+                                                    source = Path.Combine(this.ExportBasePath, tableName, row.GetPrimaryKey('.'));
 
-                                                    // ensure the parent directory exists
-                                                    System.IO.Directory.CreateDirectory(Path.Combine(this.ExportBasePath, tableName));
+                                                    Directory.CreateDirectory(Path.Combine(this.ExportBasePath, tableName));
 
-                                                    using (var fs = System.IO.File.Create(sourceFile))
+                                                    using (var fs = File.Create(source))
                                                     {
                                                         int bytesRead;
-                                                        var buffer = new byte[512];
+                                                        var buffer = new byte[4096];
 
                                                         while (0 != (bytesRead = rowRecord.GetStream(i + 1, buffer, buffer.Length)))
                                                         {
@@ -192,10 +208,10 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                                                         }
                                                     }
 
-                                                    this.exportedFiles.Add(sourceFile);
+                                                    exportedFiles.Add(source);
                                                 }
 
-                                                row[i] = sourceFile;
+                                                row[i] = source;
                                                 break;
                                             default:
                                                 var value = rowRecord.GetString(i + 1);
@@ -203,27 +219,26 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                                                 switch (row.Fields[i].Column.Category)
                                                 {
                                                     case ColumnCategory.Guid:
-                                                        value = value.ToUpper(CultureInfo.InvariantCulture);
+                                                        value = value.ToUpperInvariant();
                                                         break;
                                                 }
 
-                                                // de-modularize
-                                                if (!this.SuppressDemodularization && OutputType.Module == output.Type && ColumnModularizeType.None != row.Fields[i].Column.ModularizeType)
+                                                // De-modularize
+                                                if (this.EnableDemodularization && OutputType.Module == output.Type && ColumnModularizeType.None != row.Fields[i].Column.ModularizeType)
                                                 {
-                                                    var modularization = new Regex(@"\.[0-9A-Fa-f]{8}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{12}");
-
                                                     if (null == modularizationGuid)
                                                     {
-                                                        var match = modularization.Match(value);
+                                                        var match = Modularization.Match(value);
                                                         if (match.Success)
                                                         {
                                                             modularizationGuid = String.Concat('{', match.Value.Substring(1).Replace('_', '-'), '}');
                                                         }
                                                     }
 
-                                                    value = modularization.Replace(value, String.Empty);
+                                                    value = Modularization.Replace(value, String.Empty);
                                                 }
 
+#if TODO_MOVE_TO_DECOMPILER
                                                 // escape "$(" for the preprocessor
                                                 value = value.Replace("$(", "$$(");
 
@@ -234,6 +249,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                                                 //{
                                                 //    value = value.Insert(matches[j].Index, "!");
                                                 //}
+#endif
 
                                                 row[i] = value;
                                                 break;
@@ -249,33 +265,54 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
             }
             finally
             {
-                if (null != validationView)
-                {
-                    validationView.Close();
-                }
+                validationView?.Close();
             }
 
-            // set the modularization guid as the PackageCode
-            if (null != modularizationGuid)
-            {
-                var table = output.Tables["_SummaryInformation"];
+            return modularizationGuid;
+        }
 
-                foreach (var row in table.Rows)
+        private SummaryInformationBits ProcessSummaryInfo(WindowsInstallerData output, string modularizationGuid)
+        {
+            var result = new SummaryInformationBits();
+
+            if (!this.SkipSummaryInfo)
+            {
+                using (var summaryInformation = new SummaryInformation(this.Database))
                 {
-                    if (9 == (int)row[0]) // PID_REVNUMBER
+                    var table = new Table(this.TableDefinitions["_SummaryInformation"]);
+
+                    for (var i = 1; 19 >= i; i++)
                     {
-                        row[1] = modularizationGuid;
+                        var value = summaryInformation.GetProperty(i);
+
+                        // Set the modularization guid as the PackageCode, for merge modules.
+                        if (i == (int)SummaryInformation.Package.PackageCode && !String.IsNullOrEmpty(modularizationGuid))
+                        {
+                            var row = table.CreateRow(output.SourceLineNumbers);
+                            row[0] = i;
+                            row[1] = modularizationGuid;
+                        }
+                        else if (0 < value.Length)
+                        {
+                            var row = table.CreateRow(output.SourceLineNumbers);
+                            row[0] = i;
+                            row[1] = value;
+
+                            if (i == (int)SummaryInformation.Package.FileAndElevatedFlags)
+                            {
+                                var wordcount = Convert.ToInt32(value, CultureInfo.InvariantCulture);
+                                result.LongFilenames = (wordcount & 0x1) != 0x1;
+                                result.Compressed = (wordcount & 0x2) == 0x2;
+                                result.AdminImage = (wordcount & 0x4) == 0x4;
+                            }
+                        }
                     }
-                }
-            }
 
-            if (this.IsAdminImage)
-            {
-                this.GenerateWixFileTable(this.DatabasePath, output);
-                this.GenerateSectionIds(output);
+                    output.Tables.Add(table);
+                }
             }
 
-            return output;
+            return result;
         }
 
         private TableDefinition GetTableDefinition(string tableName, View tableView, View validationView)
@@ -310,10 +347,6 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                     var columnName = columnNameRecord.GetString(i);
                     var idtType = columnTypeRecord.GetString(i);
 
-                    ColumnType columnType;
-                    int length;
-                    bool nullable;
-
                     var columnCategory = ColumnCategory.Unknown;
                     var columnModularizeType = ColumnModularizeType.None;
                     var primary = tablePrimaryKeys.Contains(columnName);
@@ -326,7 +359,8 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                     string description = null;
 
                     // get the column type, length, and whether its nullable
-                    switch (Char.ToLower(idtType[0], CultureInfo.InvariantCulture))
+                    ColumnType columnType;
+                    switch (Char.ToLowerInvariant(idtType[0]))
                     {
                         case 'i':
                             columnType = ColumnType.Number;
@@ -345,8 +379,8 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                             columnType = ColumnType.Unknown;
                             break;
                     }
-                    length = Convert.ToInt32(idtType.Substring(1), CultureInfo.InvariantCulture);
-                    nullable = Char.IsUpper(idtType[0]);
+                    var length = Convert.ToInt32(idtType.Substring(1), CultureInfo.InvariantCulture);
+                    var nullable = Char.IsUpper(idtType[0]);
 
                     // try to get validation information
                     if (null != validationView)
@@ -385,11 +419,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                                 // convert category to ColumnCategory
                                 if (null != category)
                                 {
-                                    try
-                                    {
-                                        columnCategory = (ColumnCategory)Enum.Parse(typeof(ColumnCategory), category, true);
-                                    }
-                                    catch (ArgumentException)
+                                    if (!Enum.TryParse(category, true, out columnCategory))
                                     {
                                         columnCategory = ColumnCategory.Unknown;
                                     }
@@ -427,67 +457,103 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
             return new TableDefinition(tableName, null, columns, false);
         }
 
-        /// <summary>
-        /// Generates the WixFile table based on a path to an admin image msi and an Output.
-        /// </summary>
-        /// <param name="databaseFile">The path to the msi database file in an admin image.</param>
-        /// <param name="output">The Output that represents the msi database.</param>
-        private void GenerateWixFileTable(string databaseFile, WindowsInstallerData output)
+        private void UpdateUnrealFileColumns(string databaseFile, WindowsInstallerData output, SummaryInformationBits summaryInformation, List<string> exportedFiles)
         {
-            throw new NotImplementedException();
-#if TODO_FIX_UNBINDING_FILES
-            var adminRootPath = Path.GetDirectoryName(databaseFile);
+            var fileRows = output.Tables["File"]?.Rows;
 
-            var componentDirectoryIndex = new Hashtable();
-            var componentTable = output.Tables["Component"];
-            foreach (var row in componentTable.Rows)
+            if (fileRows == null || fileRows.Count == 0)
             {
-                componentDirectoryIndex.Add(row[0], row[2]);
+                return;
             }
 
+            this.UpdateFileRowsDiskId(output, fileRows);
+
+            this.UpdateFileRowsSource(databaseFile, output, fileRows, summaryInformation, exportedFiles);
+        }
+
+        private void UpdateFileRowsDiskId(WindowsInstallerData output, IList<Row> fileRows)
+        {
+            var mediaRows = output.Tables["Media"]?.Rows?.Cast<MediaRow>()?.OrderBy(r => r.LastSequence)?.ToList();
+
+            var lastMediaRowIndex = 0;
+            var lastMediaRow = (mediaRows == null || mediaRows.Count == 0) ? null : mediaRows[lastMediaRowIndex];
+
+            foreach (var fileRow in fileRows.Cast<FileRow>()?.OrderBy(r => r.Sequence))
+            {
+                while (lastMediaRow != null && fileRow.Sequence > lastMediaRow.LastSequence)
+                {
+                    ++lastMediaRowIndex;
+
+                    lastMediaRow = lastMediaRowIndex < mediaRows.Count ? mediaRows[lastMediaRowIndex] : null;
+                }
+
+                fileRow.DiskId = lastMediaRow?.DiskId ?? 1;
+            }
+        }
+
+        private void UpdateFileRowsSource(string databasePath, WindowsInstallerData output, IList<Row> fileRows, SummaryInformationBits summaryInformation, List<string> exportedFiles)
+        {
+            var databaseFolder = Path.GetDirectoryName(databasePath);
+
+            var componentDirectoryIndex = output.Tables["Component"].Rows.Cast<ComponentRow>().ToDictionary(r => r.Component, r => r.Directory);
+
             // Index full source paths for all directories
-            var directoryDirectoryParentIndex = new Hashtable();
-            var directoryFullPathIndex = new Hashtable();
-            var directorySourceNameIndex = new Hashtable();
+            var directories = new Dictionary<string, IResolvedDirectory>();
+
             var directoryTable = output.Tables["Directory"];
             foreach (var row in directoryTable.Rows)
             {
-                directoryDirectoryParentIndex.Add(row[0], row[1]);
-                if (null == row[1])
-                {
-                    directoryFullPathIndex.Add(row[0], adminRootPath);
-                }
-                else
-                {
-                    directorySourceNameIndex.Add(row[0], GetAdminSourceName((string)row[2]));
-                }
+                var sourceName = this.BackendHelper.GetMsiFileName(row.FieldAsString(2), source: true, longName: summaryInformation.LongFilenames);
+                var resolvedDirectory = this.BackendHelper.CreateResolvedDirectory(row.FieldAsString(1), sourceName);
+
+                directories.Add(row.FieldAsString(0), resolvedDirectory);
             }
 
-            foreach (DictionaryEntry directoryEntry in directoryDirectoryParentIndex)
+            if (summaryInformation.AdminImage)
             {
-                if (!directoryFullPathIndex.ContainsKey(directoryEntry.Key))
+                foreach (var fileRow in fileRows.Cast<FileRow>())
                 {
-                    this.GetAdminFullPath((string)directoryEntry.Key, directoryDirectoryParentIndex, directorySourceNameIndex, directoryFullPathIndex);
+                    var directoryId = componentDirectoryIndex[fileRow.Component];
+                    var relativeFileLayoutPath = this.PathResolver.GetFileSourcePath(directories, directoryId, fileRow.FileName, compressed: false, useLongName: summaryInformation.LongFilenames);
+
+                    fileRow.Source = Path.Combine(databaseFolder, relativeFileLayoutPath);
                 }
             }
-
-            var fileTable = output.Tables["File"];
-            var wixFileTable = output.EnsureTable(this.TableDefinitions["WixFile"]);
-            foreach (var row in fileTable.Rows)
+            else
             {
-                var wixFileRow = new WixFileRow(null, this.TableDefinitions["WixFile"]);
-                wixFileRow.File = (string)row[0];
-                wixFileRow.Directory = (string)componentDirectoryIndex[(string)row[1]];
-                wixFileRow.Source = Path.Combine((string)directoryFullPathIndex[wixFileRow.Directory], GetAdminSourceName((string)row[2]));
+                var extractedFileIds = new HashSet<string>();
 
-                if (!File.Exists(wixFileRow.Source))
+                if (!String.IsNullOrEmpty(this.ExtractFilesFolder))
                 {
-                    throw new WixException(ErrorMessages.WixFileNotFound(wixFileRow.Source));
+                    var extractCommand = new ExtractCabinetsCommand(output, this.Database, this.DatabasePath, this.ExtractFilesFolder, this.IntermediateFolder);
+                    extractCommand.Execute();
+
+                    extractedFileIds = new HashSet<string>(extractCommand.ExtractedFileIdsWithMediaRow.Keys, StringComparer.OrdinalIgnoreCase);
+                    exportedFiles.AddRange(extractedFileIds);
                 }
 
-                wixFileTable.Rows.Add(wixFileRow);
+                foreach (var fileRow in fileRows.Cast<FileRow>())
+                {
+                    var source = "FILE NOT EXPORTED";
+
+                    if (fileRow.Compressed == YesNoType.Yes || (fileRow.Compressed == YesNoType.NotSet && summaryInformation.Compressed))
+                    {
+                        if (extractedFileIds.Contains(fileRow.File))
+                        {
+                            source = Path.Combine(this.ExtractFilesFolder, fileRow.File);
+                        }
+                    }
+                    else
+                    {
+                        var directoryId = componentDirectoryIndex[fileRow.Component];
+                        var relativeFileLayoutPath = this.PathResolver.GetFileSourcePath(directories, directoryId, fileRow.FileName, compressed: false, useLongName: summaryInformation.LongFilenames);
+
+                        source = Path.Combine(databaseFolder, relativeFileLayoutPath);
+                    }
+
+                    fileRow.Source = source;
+                }
             }
-#endif
         }
 
         /// <summary>
@@ -620,7 +686,6 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
             {
                 switch (table.Name)
                 {
-                    case "WixFile":
                     case "MsiFileHash":
                         ConnectTableToSection(table, fileSectionIdIndex, 0);
                         break;
@@ -699,7 +764,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                 }
             }
 
-            // Now pass the output to each unbinder extension to allow them to analyze the output and determine thier proper section ids.
+            // Now pass the output to each unbinder extension to allow them to analyze the output and determine their proper section ids.
             //foreach (IUnbinderExtension extension in this.unbinderExtensions)
             //{
             //    extension.GenerateSectionIds(output);
@@ -711,19 +776,22 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
         /// </summary>
         /// <param name="table">The table to add sections to.</param>
         /// <param name="rowPrimaryKeyIndex">The index of the column which is used by other tables to reference this table.</param>
-        /// <returns>A Hashtable containing the tables key for each row paired with its assigned section id.</returns>
-        private Hashtable AssignSectionIdsToTable(Table table, int rowPrimaryKeyIndex)
+        /// <returns>A dictionary containing the tables key for each row paired with its assigned section id.</returns>
+        private Dictionary<string, string> AssignSectionIdsToTable(Table table, int rowPrimaryKeyIndex)
         {
-            var hashtable = new Hashtable();
+            var primaryKeyToSectionId = new Dictionary<string, string>();
+
             if (null != table)
             {
                 foreach (var row in table.Rows)
                 {
                     row.SectionId = this.GetNewSectionId();
-                    hashtable.Add(row[rowPrimaryKeyIndex], row.SectionId);
+
+                    primaryKeyToSectionId.Add(row.FieldAsString(rowPrimaryKeyIndex), row.SectionId);
                 }
             }
-            return hashtable;
+
+            return primaryKeyToSectionId;
         }
 
         /// <summary>
@@ -732,15 +800,15 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
         /// <param name="table">The table containing rows that need to be connected to sections.</param>
         /// <param name="sectionIdIndex">A hashtable containing keys to map table to its section.</param>
         /// <param name="rowIndex">The index of the column which is used as the foreign key in to the sectionIdIndex.</param>
-        private static void ConnectTableToSection(Table table, Hashtable sectionIdIndex, int rowIndex)
+        private static void ConnectTableToSection(Table table, Dictionary<string, string> sectionIdIndex, int rowIndex)
         {
             if (null != table)
             {
                 foreach (var row in table.Rows)
                 {
-                    if (sectionIdIndex.ContainsKey(row[rowIndex]))
+                    if (sectionIdIndex.TryGetValue(row.FieldAsString(rowIndex), out var sectionId))
                     {
-                        row.SectionId = (string)sectionIdIndex[row[rowIndex]];
+                        row.SectionId = sectionId;
                     }
                 }
             }
@@ -750,40 +818,53 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
         /// Connects a table's rows to an already sectioned table and produces an index for other tables to connect to it.
         /// </summary>
         /// <param name="table">The table containing rows that need to be connected to sections.</param>
-        /// <param name="sectionIdIndex">A hashtable containing keys to map table to its section.</param>
+        /// <param name="sectionIdIndex">A dictionary containing keys to map table to its section.</param>
         /// <param name="rowIndex">The index of the column which is used as the foreign key in to the sectionIdIndex.</param>
         /// <param name="rowPrimaryKeyIndex">The index of the column which is used by other tables to reference this table.</param>
-        /// <returns>A Hashtable containing the tables key for each row paired with its assigned section id.</returns>
-        private static Hashtable ConnectTableToSectionAndIndex(Table table, Hashtable sectionIdIndex, int rowIndex, int rowPrimaryKeyIndex)
+        /// <returns>A dictionary containing the tables key for each row paired with its assigned section id.</returns>
+        private static Dictionary<string, string> ConnectTableToSectionAndIndex(Table table, Dictionary<string, string> sectionIdIndex, int rowIndex, int rowPrimaryKeyIndex)
         {
-            var newHashTable = new Hashtable();
+            var newPrimaryKeyToSectionId = new Dictionary<string, string>();
+
             if (null != table)
             {
                 foreach (var row in table.Rows)
                 {
-                    if (!sectionIdIndex.ContainsKey(row[rowIndex]))
+                    var foreignKey = row.FieldAsString(rowIndex);
+
+                    if (!sectionIdIndex.TryGetValue(foreignKey, out var sectionId))
                     {
                         continue;
                     }
 
-                    row.SectionId = (string)sectionIdIndex[row[rowIndex]];
-                    if (null != row[rowPrimaryKeyIndex])
+                    row.SectionId = sectionId;
+
+                    var primaryKey = row.FieldAsString(rowPrimaryKeyIndex);
+
+                    if (!String.IsNullOrEmpty(primaryKey) && sectionIdIndex.ContainsKey(primaryKey))
                     {
-                        newHashTable.Add(row[rowPrimaryKeyIndex], row.SectionId);
+                        newPrimaryKeyToSectionId.Add(primaryKey, row.SectionId);
                     }
                 }
             }
-            return newHashTable;
+
+            return newPrimaryKeyToSectionId;
         }
 
-        /// <summary>
-        /// Creates a new section identifier to be used when adding a section to an output.
-        /// </summary>
-        /// <returns>A string representing a new section id.</returns>
         private string GetNewSectionId()
         {
-            this.SectionCount++;
-            return "wix.section." + this.SectionCount.ToString(CultureInfo.InvariantCulture);
+            this.sectionCount++;
+
+            return "wix.section." + this.sectionCount.ToString(CultureInfo.InvariantCulture);
+        }
+
+        private class SummaryInformationBits
+        {
+            public bool AdminImage { get; set; }
+
+            public bool Compressed { get; set; }
+
+            public bool LongFilenames { get; set; }
         }
     }
 }
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs
deleted file mode 100644
index 8070d42d..00000000
--- a/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindMsiOrMsmCommand.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
-
-namespace WixToolset.Core.WindowsInstaller.Unbind
-{
-    using System;
-    using System.ComponentModel;
-    using WixToolset.Core.Native.Msi;
-    using WixToolset.Data;
-    using WixToolset.Data.WindowsInstaller;
-    using WixToolset.Extensibility.Services;
-
-    internal class UnbindMsiOrMsmCommand
-    {
-        public UnbindMsiOrMsmCommand(IMessaging messaging, IBackendHelper backendHelper, string databasePath, string exportBasePath, string intermediateFolder, bool adminImage, bool suppressDemodularization, bool suppressExtractCabinets)
-        {
-            this.Messaging = messaging;
-            this.BackendHelper = backendHelper;
-            this.DatabasePath = databasePath;
-            this.ExportBasePath = exportBasePath;
-            this.IntermediateFolder = intermediateFolder;
-            this.IsAdminImage = adminImage;
-            this.SuppressDemodularization = suppressDemodularization;
-            this.SuppressExtractCabinets = suppressExtractCabinets;
-        }
-
-        private IMessaging Messaging { get; }
-
-        private IBackendHelper BackendHelper { get; }
-
-        private string DatabasePath { get; }
-
-        private string ExportBasePath { get; }
-
-        private string IntermediateFolder { get; }
-
-        private bool IsAdminImage { get; }
-
-        private bool SuppressDemodularization { get; }
-
-        private bool SuppressExtractCabinets { get; }
-
-        public WindowsInstallerData Execute()
-        {
-            try
-            {
-                using (var database = new Database(this.DatabasePath, OpenDatabase.ReadOnly))
-                {
-                    var unbindCommand = new UnbindDatabaseCommand(this.Messaging, this.BackendHelper, database, this.DatabasePath, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, this.IsAdminImage, this.SuppressDemodularization, skipSummaryInfo: false);
-                    var data = unbindCommand.Execute();
-
-                    // extract the files from the cabinets
-                    if (!String.IsNullOrEmpty(this.ExportBasePath) && !this.SuppressExtractCabinets)
-                    {
-                        var extractCommand = new ExtractCabinetsCommand(data, database, this.DatabasePath, this.ExportBasePath, this.IntermediateFolder);
-                        extractCommand.Execute();
-                    }
-
-                    return data;
-                }
-            }
-            catch (Win32Exception e)
-            {
-                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
-                {
-                    //throw new WixException(WixErrors.OpenDatabaseFailed(this.DatabasePath));
-                }
-
-                throw;
-            }
-        }
-    }
-}
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindTransformCommand.cs b/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindTransformCommand.cs
index 01ff1a80..bce60e40 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindTransformCommand.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/Unbind/UnbindTransformCommand.cs
@@ -1,5 +1,7 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
 
+#if TODO_KEEP_FOR_PATCH_UNBINDING_CONSIDERATION_IN_FUTURE
+
 namespace WixToolset.Core.WindowsInstaller.Unbind
 {
     using System;
@@ -17,10 +19,11 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
 
     internal class UnbindTransformCommand
     {
-        public UnbindTransformCommand(IMessaging messaging, IBackendHelper backendHelper, string transformFile, string exportBasePath, string intermediateFolder)
+        public UnbindTransformCommand(IMessaging messaging, IBackendHelper backendHelper, FileSystemManager fileSystemManager, string transformFile, string exportBasePath, string intermediateFolder)
         {
             this.Messaging = messaging;
             this.BackendHelper = backendHelper;
+            this.FileSystemManager = fileSystemManager;
             this.TransformFile = transformFile;
             this.ExportBasePath = exportBasePath;
             this.IntermediateFolder = intermediateFolder;
@@ -32,6 +35,8 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
 
         private IBackendHelper BackendHelper { get; }
 
+        private FileSystemManager FileSystemManager { get; }
+
         private string TransformFile { get; }
 
         private string ExportBasePath { get; }
@@ -90,7 +95,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                 msiDatabase.ApplyTransform(this.TransformFile, TransformErrorConditions.All | TransformErrorConditions.ViewTransform);
 
                 // unbind the database
-                var unbindCommand = new UnbindDatabaseCommand(this.Messaging, this.BackendHelper, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, false, false, skipSummaryInfo: true);
+                var unbindCommand = new UnbindDatabaseCommand(this.Messaging, this.BackendHelper, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, enableDemodularization: false, skipSummaryInfo: true);
                 var transformViewOutput = unbindCommand.Execute();
 
                 // index the added and possibly modified rows (added rows may also appears as modified rows)
@@ -160,7 +165,7 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
                 }
 
                 // unbind the database
-                var unbindCommand = new UnbindDatabaseCommand(this.Messaging, this.BackendHelper, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, false, false, skipSummaryInfo: true);
+                var unbindCommand = new UnbindDatabaseCommand(this.Messaging, this.BackendHelper, msiDatabase, msiDatabaseFile, OutputType.Product, this.ExportBasePath, this.IntermediateFolder, enableDemodularization: false, skipSummaryInfo: true);
                 var output = unbindCommand.Execute();
 
                 // index all the rows to easily find modified rows
@@ -302,8 +307,9 @@ namespace WixToolset.Core.WindowsInstaller.Unbind
 
         private void GenerateDatabase(WindowsInstallerData output, string databaseFile)
         {
-            var command = new GenerateDatabaseCommand(this.Messaging, null, null, output, databaseFile, this.TableDefinitions, this.IntermediateFolder, keepAddedColumns: true, suppressAddingValidationRows: true, useSubdirectory: false);
+            var command = new GenerateDatabaseCommand(this.Messaging, this.BackendHelper, this.FileSystemManager, output, databaseFile, this.TableDefinitions, this.IntermediateFolder, keepAddedColumns: true, suppressAddingValidationRows: true, useSubdirectory: false);
             command.Execute();
         }
     }
 }
+#endif
diff --git a/src/wix/WixToolset.Core.WindowsInstaller/WindowsInstallerDecompiler.cs b/src/wix/WixToolset.Core.WindowsInstaller/WindowsInstallerDecompiler.cs
index b35e3587..c78ea93a 100644
--- a/src/wix/WixToolset.Core.WindowsInstaller/WindowsInstallerDecompiler.cs
+++ b/src/wix/WixToolset.Core.WindowsInstaller/WindowsInstallerDecompiler.cs
@@ -3,11 +3,9 @@
 namespace WixToolset.Core.WindowsInstaller
 {
     using System;
-    using System.Collections.Generic;
-    using System.ComponentModel;
+    using System.ComponentModel.Design;
     using System.IO;
     using System.Linq;
-    using WixToolset.Core.Native.Msi;
     using WixToolset.Core.WindowsInstaller.Decompile;
     using WixToolset.Core.WindowsInstaller.Unbind;
     using WixToolset.Data;
@@ -63,56 +61,32 @@ namespace WixToolset.Core.WindowsInstaller
 
         private IWindowsInstallerDecompileResult Execute(IWindowsInstallerDecompileContext context)
         {
-            var result = context.ServiceProvider.GetService<IWindowsInstallerDecompileResult>();
-
-            try
+            // Delete the directory and its files to prevent cab extraction failure due to an existing file.
+            if (Directory.Exists(context.ExtractFolder))
             {
-                using (var database = new Database(context.DecompilePath, OpenDatabase.ReadOnly))
-                {
-                    // Delete the directory and its files to prevent cab extraction failure due to an existing file.
-                    if (Directory.Exists(context.ExtractFolder))
-                    {
-                        Directory.Delete(context.ExtractFolder, true);
-                    }
-
-                    var backendHelper = context.ServiceProvider.GetService<IWindowsInstallerBackendHelper>();
-                    var decompilerHelper = context.ServiceProvider.GetService<IWindowsInstallerDecompilerHelper>();
-
-                    var unbindCommand = new UnbindDatabaseCommand(this.Messaging, backendHelper, database, context.DecompilePath, context.DecompileType, context.ExtractFolder, context.IntermediateFolder, context.IsAdminImage, suppressDemodularization: false, skipSummaryInfo: false);
-                    var output = unbindCommand.Execute();
-                    var extractedFilePaths = new List<string>(unbindCommand.ExportedFiles);
-
-                    var decompiler = new Decompiler(this.Messaging, backendHelper, decompilerHelper, context.Extensions, context.ExtensionData, context.SymbolDefinitionCreator, context.BaseSourcePath, context.SuppressCustomTables, context.SuppressDroppingEmptyTables, context.SuppressRelativeActionSequencing, context.SuppressUI, context.TreatProductAsModule);
-                    result.Document = decompiler.Decompile(output);
-
-                    result.Platform = GetPlatformFromOutput(output);
-
-                    // extract the files from the cabinets
-                    if (!String.IsNullOrEmpty(context.ExtractFolder) && !context.SuppressExtractCabinets)
-                    {
-                        var fileDirectory = String.IsNullOrEmpty(context.CabinetExtractFolder) ? Path.Combine(context.ExtractFolder, "File") : context.CabinetExtractFolder;
-
-                        var extractCommand = new ExtractCabinetsCommand(output, database, context.DecompilePath, fileDirectory, context.IntermediateFolder, context.TreatProductAsModule);
-                        extractCommand.Execute();
-
-                        extractedFilePaths.AddRange(extractCommand.ExtractedFiles);
-                        result.ExtractedFilePaths = extractedFilePaths;
-                    }
-                    else
-                    {
-                        result.ExtractedFilePaths = new string[0];
-                    }
-                }
+                Directory.Delete(context.ExtractFolder, true);
             }
-            catch (Win32Exception e)
-            {
-                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
-                {
-                    throw new WixException(ErrorMessages.OpenDatabaseFailed(context.DecompilePath));
-                }
 
-                throw;
-            }
+            var backendHelper = context.ServiceProvider.GetService<IWindowsInstallerBackendHelper>();
+
+            var pathResolver = context.ServiceProvider.GetService<IPathResolver>();
+
+            var extractFilesFolder = context.SuppressExtractCabinets || (String.IsNullOrEmpty(context.CabinetExtractFolder) && String.IsNullOrEmpty(context.ExtractFolder)) ? null :
+                String.IsNullOrEmpty(context.CabinetExtractFolder) ? Path.Combine(context.ExtractFolder, "File") : context.CabinetExtractFolder;
+
+            var outputType = context.TreatProductAsModule ? OutputType.Module : context.DecompileType;
+            var unbindCommand = new UnbindDatabaseCommand(this.Messaging, backendHelper, pathResolver, context.DecompilePath, outputType, context.ExtractFolder, extractFilesFolder, context.IntermediateFolder, enableDemodularization: true, skipSummaryInfo: false);
+            var output = unbindCommand.Execute();
+            var extractedFilePaths = unbindCommand.ExportedFiles;
+
+            var decompilerHelper = context.ServiceProvider.GetService<IWindowsInstallerDecompilerHelper>();
+            var decompiler = new Decompiler(this.Messaging, backendHelper, decompilerHelper, context.Extensions, context.ExtensionData, context.SymbolDefinitionCreator, context.BaseSourcePath, context.SuppressCustomTables, context.SuppressDroppingEmptyTables, context.SuppressRelativeActionSequencing, context.SuppressUI, context.TreatProductAsModule);
+            var document = decompiler.Decompile(output);
+
+            var result = context.ServiceProvider.GetService<IWindowsInstallerDecompileResult>();
+            result.Document = document;
+            result.Platform = GetPlatformFromOutput(output);
+            result.ExtractedFilePaths = extractedFilePaths.ToList();
 
             return result;
         }
diff --git a/src/wix/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs b/src/wix/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
index a0798e62..025affd3 100644
--- a/src/wix/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
+++ b/src/wix/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
@@ -4,7 +4,6 @@ namespace WixToolset.Core.Bind
 {
     using System;
     using System.Collections.Generic;
-    using System.Globalization;
     using System.IO;
     using System.Linq;
     using System.Security.Cryptography;
@@ -41,9 +40,9 @@ namespace WixToolset.Core.Bind
             {
                 var localFileNameWithoutExtension = Path.GetFileNameWithoutExtension(uri.LocalPath);
                 var unique = this.HashUri(uri.AbsoluteUri);
-                var extractedName = String.Format(CultureInfo.InvariantCulture, @"{0}_{1}\{2}", localFileNameWithoutExtension, unique, embeddedFileId);
+                var extractedName = String.Concat(localFileNameWithoutExtension, "_", unique);
 
-                extractPath = Path.GetFullPath(Path.Combine(extractFolder, extractedName));
+                extractPath = Path.GetFullPath(Path.Combine(extractFolder, extractedName, embeddedFileId));
                 extracts.Add(embeddedFileId, extractPath);
             }
 
diff --git a/src/wix/WixToolset.Core/Bind/ResolveFieldsCommand.cs b/src/wix/WixToolset.Core/Bind/ResolveFieldsCommand.cs
index 794208e5..8a5299d9 100644
--- a/src/wix/WixToolset.Core/Bind/ResolveFieldsCommand.cs
+++ b/src/wix/WixToolset.Core/Bind/ResolveFieldsCommand.cs
@@ -16,186 +16,121 @@ namespace WixToolset.Core.Bind
     /// </summary>
     internal class ResolveFieldsCommand
     {
-        public IMessaging Messaging { private get; set; }
+        public ResolveFieldsCommand(IMessaging messaging, IFileResolver fileResolver, IVariableResolver variableResolver, IReadOnlyCollection<IBindPath> bindPaths, IReadOnlyCollection<IResolverExtension> extensions, ExtractEmbeddedFiles filesWithEmbeddedFiles, string intermediateFolder, Intermediate intermediate, bool allowUnresolvedVariables)
+        {
+            this.Messaging = messaging;
+            this.FileResolver = fileResolver;
+            this.VariableResolver = variableResolver;
+            this.BindPaths = bindPaths;
+            this.Extensions = extensions;
+            this.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+            this.IntermediateFolder = intermediateFolder;
+            this.Intermediate = intermediate;
+            this.AllowUnresolvedVariables = allowUnresolvedVariables;
+        }
 
-        public bool BuildingPatch { private get; set; }
+        private IMessaging Messaging { get; }
 
-        public IVariableResolver VariableResolver { private get; set; }
+        private IFileResolver FileResolver { get; }
 
-        public IEnumerable<IBindPath> BindPaths { private get; set; }
+        private IVariableResolver VariableResolver { get; }
 
-        public IEnumerable<IResolverExtension> Extensions { private get; set; }
+        private IEnumerable<IBindPath> BindPaths { get; }
 
-        public ExtractEmbeddedFiles FilesWithEmbeddedFiles { private get; set; }
+        private IEnumerable<IResolverExtension> Extensions { get; }
 
-        public string IntermediateFolder { private get; set; }
+        private ExtractEmbeddedFiles FilesWithEmbeddedFiles { get; }
 
-        public Intermediate Intermediate { private get; set; }
+        private string IntermediateFolder { get; }
 
-        public bool SupportDelayedResolution { private get; set; }
+        private Intermediate Intermediate { get; }
 
-        public bool AllowUnresolvedVariables { private get; set; }
+        private bool AllowUnresolvedVariables { get; }
 
         public IReadOnlyCollection<DelayedField> DelayedFields { get; private set; }
 
         public void Execute()
         {
-            var delayedFields = this.SupportDelayedResolution ? new List<DelayedField>() : null;
+            var delayedFields = new List<DelayedField>();
 
-            var fileResolver = new FileResolver(this.BindPaths, this.Extensions);
+            var bindPaths = this.BindPaths.Where(b => b.Stage == BindStage.Normal).ToList();
 
             // Build the column lookup only when needed.
             Dictionary<string, WixCustomTableColumnSymbol> customColumnsById = null;
 
-            foreach (var sections in this.Intermediate.Sections)
+            foreach (var symbol in this.Intermediate.Sections.SelectMany(s => s.Symbols))
             {
-                foreach (var symbol in sections.Symbols)
+                foreach (var field in symbol.Fields.Where(f => !f.IsNull()))
                 {
-                    foreach (var field in symbol.Fields)
+                    var fieldType = field.Type;
+
+                    // Custom table cells require an extra look up to the column definition as the
+                    // cell's data type is always a string (because strings can store anything) but
+                    // the column definition may be more specific.
+                    if (symbol.Definition.Type == SymbolDefinitionType.WixCustomTableCell)
                     {
-                        if (field.IsNull())
+                        // We only care about the Data in a CustomTable cell.
+                        if (field.Name != nameof(WixCustomTableCellSymbolFields.Data))
                         {
                             continue;
                         }
 
-                        var fieldType = field.Type;
-
-                        // Custom table cells require an extra look up to the column definition as the
-                        // cell's data type is always a string (because strings can store anything) but
-                        // the column definition may be more specific.
-                        if (symbol.Definition.Type == SymbolDefinitionType.WixCustomTableCell)
+                        if (customColumnsById == null)
                         {
-                            // We only care about the Data in a CustomTable cell.
-                            if (field.Name != nameof(WixCustomTableCellSymbolFields.Data))
-                            {
-                                continue;
-                            }
-
-                            if (customColumnsById == null)
-                            {
-                                customColumnsById = this.Intermediate.Sections.SelectMany(s => s.Symbols.OfType<WixCustomTableColumnSymbol>()).ToDictionary(t => t.Id.Id);
-                            }
-
-                            if (customColumnsById.TryGetValue(symbol.Fields[(int)WixCustomTableCellSymbolFields.TableRef].AsString() + "/" + symbol.Fields[(int)WixCustomTableCellSymbolFields.ColumnRef].AsString(), out var customColumn))
-                            {
-                                fieldType = customColumn.Type;
-                            }
+                            customColumnsById = this.Intermediate.Sections.SelectMany(s => s.Symbols.OfType<WixCustomTableColumnSymbol>()).ToDictionary(t => t.Id.Id);
                         }
 
-                        // Check to make sure we're in a scenario where we can handle variable resolution.
-                        if (null != delayedFields)
+                        if (customColumnsById.TryGetValue(symbol.Fields[(int)WixCustomTableCellSymbolFields.TableRef].AsString() + "/" + symbol.Fields[(int)WixCustomTableCellSymbolFields.ColumnRef].AsString(), out var customColumn))
                         {
-                            // resolve localization and wix variables
-                            if (fieldType == IntermediateFieldType.String)
-                            {
-                                var original = field.AsString();
-                                if (!String.IsNullOrEmpty(original))
-                                {
-                                    var resolution = this.VariableResolver.ResolveVariables(symbol.SourceLineNumbers, original, !this.AllowUnresolvedVariables);
-                                    if (resolution.UpdatedValue)
-                                    {
-                                        field.Set(resolution.Value);
-                                    }
-
-                                    if (resolution.DelayedResolve)
-                                    {
-                                        delayedFields.Add(new DelayedField(symbol, field));
-                                    }
-                                }
-                            }
-                        }
-
-                        // Move to next symbol if we've hit an error resolving variables.
-                        if (this.Messaging.EncounteredError) // TODO: make this error handling more specific to just the failure to resolve variables in this field.
-                        {
-                            continue;
+                            fieldType = customColumn.Type;
                         }
+                    }
 
-                        // Resolve file paths
-                        if (fieldType == IntermediateFieldType.Path)
+                    // Check to make sure we're in a scenario where we can handle variable resolution.
+                    if (null != delayedFields)
+                    {
+                        // resolve localization and wix variables
+                        if (fieldType == IntermediateFieldType.String)
                         {
-                            this.ResolvePathField(fileResolver, symbol, field);
-
-#if TODO_PATCHING
-                            if (null != objectField.PreviousData)
+                            var original = field.AsString();
+                            if (!String.IsNullOrEmpty(original))
                             {
-                                objectField.PreviousData = this.BindVariableResolver.ResolveVariables(symbol.SourceLineNumbers, objectField.PreviousData, false, out isDefault);
-
-                                if (!Messaging.Instance.EncounteredError) // TODO: make this error handling more specific to just the failure to resolve variables in this field.
+                                var resolution = this.VariableResolver.ResolveVariables(symbol.SourceLineNumbers, original, !this.AllowUnresolvedVariables);
+                                if (resolution.UpdatedValue)
                                 {
-                                    // file is compressed in a cabinet (and not modified above)
-                                    if (objectField.PreviousEmbeddedFileIndex.HasValue && isDefault)
-                                    {
-                                        // when loading transforms from disk, PreviousBaseUri may not have been set
-                                        if (null == objectField.PreviousBaseUri)
-                                        {
-                                            objectField.PreviousBaseUri = objectField.BaseUri;
-                                        }
-
-                                        string extractPath = this.FilesWithEmbeddedFiles.AddEmbeddedFileIndex(objectField.PreviousBaseUri, objectField.PreviousEmbeddedFileIndex.Value, this.IntermediateFolder);
-
-                                        // set the path to the file once its extracted from the cabinet
-                                        objectField.PreviousData = extractPath;
-                                    }
-                                    else if (null != objectField.PreviousData) // non-compressed file (or localized value)
-                                    {
-                                        try
-                                        {
-                                            if (!fileResolver.RebaseTarget && !fileResolver.RebaseUpdated)
-                                            {
-                                                // resolve the path to the file
-                                                objectField.PreviousData = fileResolver.ResolveFile((string)objectField.PreviousData, symbol.Definition.Name, symbol.SourceLineNumbers, BindStage.Normal);
-                                            }
-                                            else
-                                            {
-                                                if (fileResolver.RebaseTarget)
-                                                {
-                                                    // if -bt is used, it come here
-                                                    // Try to use the original unresolved source from either target build or update build
-                                                    // If both target and updated are of old wixpdb, it behaves the same as today, no re-base logic here
-                                                    // If target is old version and updated is new version, it uses unresolved path from updated build
-                                                    // If both target and updated are of new versions, it uses unresolved path from target build
-                                                    if (null != objectField.UnresolvedPreviousData || null != objectField.UnresolvedData)
-                                                    {
-                                                        objectField.PreviousData = objectField.UnresolvedPreviousData ?? objectField.UnresolvedData;
-                                                    }
-                                                }
-
-                                                // resolve the path to the file
-                                                objectField.PreviousData = fileResolver.ResolveFile((string)objectField.PreviousData, symbol.Definition.Name, symbol.SourceLineNumbers, BindStage.Target);
+                                    field.Set(resolution.Value);
+                                }
 
-                                            }
-                                        }
-                                        catch (WixFileNotFoundException)
-                                        {
-                                            // display the error with source line information
-                                            Messaging.Instance.Write(WixErrors.FileNotFound(symbol.SourceLineNumbers, (string)objectField.PreviousData));
-                                        }
-                                    }
+                                if (resolution.DelayedResolve)
+                                {
+                                    delayedFields.Add(new DelayedField(symbol, field));
                                 }
                             }
-#endif
                         }
                     }
+
+                    // Move to next symbol if we've hit an error resolving variables.
+                    if (this.Messaging.EncounteredError) // TODO: make this error handling more specific to just the failure to resolve variables in this field.
+                    {
+                        continue;
+                    }
+
+                    // Resolve file paths
+                    if (fieldType == IntermediateFieldType.Path)
+                    {
+                        this.ResolvePathField(this.FileResolver, bindPaths, symbol, field);
+                    }
                 }
             }
 
             this.DelayedFields = delayedFields;
         }
 
-        private void ResolvePathField(FileResolver fileResolver, IntermediateSymbol symbol, IntermediateField field)
+        private void ResolvePathField(IFileResolver fileResolver, IEnumerable<IBindPath> bindPaths, IntermediateSymbol symbol, IntermediateField field)
         {
             var fieldValue = field.AsPath();
             var originalFieldPath = fieldValue.Path;
 
-#if TODO_PATCHING
-            // Skip file resolution if the file is to be deleted.
-            if (RowOperation.Delete == symbol.Operation)
-            {
-                continue;
-            }
-#endif
-
             // If the file is embedded and if the previous value has a bind variable in the path
             // which gets modified by resolving the previous value again then switch to that newly
             // resolved path instead of using the embedded file.
@@ -221,45 +156,7 @@ namespace WixToolset.Core.Bind
             {
                 try
                 {
-                    var resolvedPath = fieldValue.Path;
-
-                    if (!this.BuildingPatch) // Normal binding for non-Patch scenario such as link (light.exe)
-                    {
-#if TODO_PATCHING
-                        // keep a copy of the un-resolved data for future replay. This will be saved into wixpdb file
-                        if (null == objectField.UnresolvedData)
-                        {
-                            objectField.UnresolvedData = (string)objectField.Data;
-                        }
-#endif
-                        resolvedPath = fileResolver.ResolveFile(fieldValue.Path, symbol.Definition, symbol.SourceLineNumbers, BindStage.Normal);
-                    }
-                    else if (!fileResolver.RebaseTarget && !fileResolver.RebaseUpdated) // Normal binding for Patch Scenario (normal patch, no re-basing logic)
-                    {
-                        resolvedPath = fileResolver.ResolveFile(fieldValue.Path, symbol.Definition, symbol.SourceLineNumbers, BindStage.Normal);
-                    }
-#if TODO_PATCHING
-                    else // Re-base binding path scenario caused by pyro.exe -bt -bu
-                    {
-                        // by default, use the resolved Data for file lookup
-                        string filePathToResolve = (string)objectField.Data;
-
-                        // if -bu is used in pyro command, this condition holds true and the tool
-                        // will use pre-resolved source for new wixpdb file
-                        if (fileResolver.RebaseUpdated)
-                        {
-                            // try to use the unResolved Source if it exists.
-                            // New version of wixpdb file keeps a copy of pre-resolved Source. i.e. !(bindpath.test)\foo.dll
-                            // Old version of winpdb file does not contain this attribute and the value is null.
-                            if (null != objectField.UnresolvedData)
-                            {
-                                filePathToResolve = objectField.UnresolvedData;
-                            }
-                        }
-
-                        objectField.Data = fileResolver.ResolveFile(filePathToResolve, symbol.Definition.Name, symbol.SourceLineNumbers, BindStage.Updated);
-                    }
-#endif
+                    var resolvedPath = fileResolver.ResolveFile(fieldValue.Path, this.Extensions, bindPaths, BindStage.Normal, symbol.SourceLineNumbers, symbol.Definition);
 
                     if (!String.Equals(originalFieldPath, resolvedPath, StringComparison.OrdinalIgnoreCase))
                     {
diff --git a/src/wix/WixToolset.Core/BindContext.cs b/src/wix/WixToolset.Core/BindContext.cs
index 9dd6aa46..1c1f7528 100644
--- a/src/wix/WixToolset.Core/BindContext.cs
+++ b/src/wix/WixToolset.Core/BindContext.cs
@@ -18,7 +18,7 @@ namespace WixToolset.Core
 
         public IServiceProvider ServiceProvider { get; }
 
-        public IReadOnlyCollection<BindPath> BindPaths { get; set; }
+        public IReadOnlyCollection<IBindPath> BindPaths { get; set; }
 
         public string BurnStubPath { get; set; }
 
diff --git a/src/wix/WixToolset.Core/CommandLine/BuildCommand.cs b/src/wix/WixToolset.Core/CommandLine/BuildCommand.cs
index dc4e0a6d..34520fc0 100644
--- a/src/wix/WixToolset.Core/CommandLine/BuildCommand.cs
+++ b/src/wix/WixToolset.Core/CommandLine/BuildCommand.cs
@@ -48,7 +48,9 @@ namespace WixToolset.Core.CommandLine
             {
                 new CommandLineHelpSwitch("-arch", "Set the architecture of the output."),
                 new CommandLineHelpSwitch("-bindfiles", "-bf", "Bind files into an output .wixlib. Ignored if not building a .wixlib."),
-                new CommandLineHelpSwitch("-bindpath", "Bind path to search for content files."),
+                new CommandLineHelpSwitch("-bindpath", "-b", "Bind path to search for content files."),
+                new CommandLineHelpSwitch("-bindpath:target", "-bt", "Bind path to search for target package's content files. Only used when building a patch."),
+                new CommandLineHelpSwitch("-bindpath:update", "-bu", "Bind path to search for update package's content files. Only used when building a patch."),
                 new CommandLineHelpSwitch("-cabcache", "-cc", "Set a folder to cache cabinets across builds."),
                 new CommandLineHelpSwitch("-culture", "Adds a culture to filter localization files."),
                 new CommandLineHelpSwitch("-define", "-d", "Sets a preprocessor variable."),
@@ -292,6 +294,7 @@ namespace WixToolset.Core.CommandLine
             {
                 {
                     var context = this.ServiceProvider.GetService<IBindContext>();
+                    context.BindPaths = bindPaths;
                     //context.CabbingThreadCount = this.CabbingThreadCount;
                     context.CabCachePath = cabCachePath;
                     context.ResolvedCodepage = resolveResult.Codepage;
@@ -534,11 +537,25 @@ namespace WixToolset.Core.CommandLine
                             this.BindFiles = true;
                             return true;
 
+                        case "b":
                         case "bindpath":
+                        case "bt":
+                        case "bindpath:target":
+                        case "bu":
+                        case "bindpath:update":
                         {
                             var value = parser.GetNextArgumentOrError(arg);
-                            if (value != null && this.TryParseBindPath(value, out var bindPath))
+                            if (value != null && this.TryParseBindPath(arg, value, out var bindPath))
                             {
+                                if (parameter == "bt" || parameter.EndsWith("target"))
+                                {
+                                    bindPath.Stage = BindStage.Target;
+                                }
+                                else if (parameter == "bu" || parameter.EndsWith("update"))
+                                {
+                                    bindPath.Stage = BindStage.Updated;
+                                }
+
                                 this.BindPaths.Add(bindPath);
                             }
                             return true;
@@ -830,7 +847,7 @@ namespace WixToolset.Core.CommandLine
                 return new InputsAndOutputs(codePaths, localizationPaths, libraryPaths, wixipls, outputPath, outputType, pdbPath, this.PdbType);
             }
 
-            private bool TryParseBindPath(string bindPath, out IBindPath bp)
+            private bool TryParseBindPath(string argument, string bindPath, out IBindPath bp)
             {
                 var namedPath = bindPath.Split(BindPathSplit, 2);
 
@@ -848,7 +865,7 @@ namespace WixToolset.Core.CommandLine
 
                 if (File.Exists(bp.Path))
                 {
-                    this.Messaging.Write(ErrorMessages.ExpectedDirectoryGotFile("-bindpath", bp.Path));
+                    this.Messaging.Write(ErrorMessages.ExpectedDirectoryGotFile(argument, bp.Path));
                     return false;
                 }
 
diff --git a/src/wix/WixToolset.Core/Compiler.cs b/src/wix/WixToolset.Core/Compiler.cs
index d04ae491..8f1ae7fb 100644
--- a/src/wix/WixToolset.Core/Compiler.cs
+++ b/src/wix/WixToolset.Core/Compiler.cs
@@ -7706,7 +7706,6 @@ namespace WixToolset.Core
             var validationFlags = TransformFlags.PatchTransformDefault;
             string baselineFile = null;
             string updateFile = null;
-            string transformFile = null;
 
             foreach (var attrib in node.Attributes())
             {
@@ -7726,9 +7725,6 @@ namespace WixToolset.Core
                     case "UpdateFile":
                         updateFile = this.Core.GetAttributeValue(sourceLineNumbers, attrib);
                         break;
-                    case "TransformFile":
-                        transformFile = this.Core.GetAttributeValue(sourceLineNumbers, attrib);
-                        break;
                     default:
                         this.Core.UnexpectedAttribute(node, attrib);
                         break;
@@ -7746,26 +7742,14 @@ namespace WixToolset.Core
                 id = Identifier.Invalid;
             }
 
-            if (!String.IsNullOrEmpty(baselineFile) || !String.IsNullOrEmpty(updateFile))
+            if (String.IsNullOrEmpty(baselineFile))
             {
-                if (String.IsNullOrEmpty(baselineFile))
-                {
-                    this.Core.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "BaselineFile", "UpdateFile"));
-                }
-
-                if (String.IsNullOrEmpty(updateFile))
-                {
-                    this.Core.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "UpdateFile", "BaselineFile"));
-                }
-
-                if (!String.IsNullOrEmpty(transformFile))
-                {
-                    this.Core.Write(ErrorMessages.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "TransformFile", !String.IsNullOrEmpty(baselineFile) ? "BaselineFile" : "UpdateFile"));
-                }
+                this.Core.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "BaselineFile"));
             }
-            else if (String.IsNullOrEmpty(transformFile))
+
+            if (String.IsNullOrEmpty(updateFile))
             {
-                this.Core.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "BaselineFile", "TransformFile", true));
+                this.Core.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "UpdateFile"));
             }
 
             foreach (var child in node.Elements())
@@ -7805,7 +7789,6 @@ namespace WixToolset.Core
                     ValidationFlags = validationFlags,
                     BaselineFile = new IntermediateFieldPathValue { Path = baselineFile },
                     UpdateFile = new IntermediateFieldPathValue { Path = updateFile },
-                    TransformFile = new IntermediateFieldPathValue { Path = transformFile },
                 });
             }
         }
diff --git a/src/wix/WixToolset.Core/ExtensibilityServices/BackendHelper.cs b/src/wix/WixToolset.Core/ExtensibilityServices/BackendHelper.cs
index 20a47637..4a5cc607 100644
--- a/src/wix/WixToolset.Core/ExtensibilityServices/BackendHelper.cs
+++ b/src/wix/WixToolset.Core/ExtensibilityServices/BackendHelper.cs
@@ -6,8 +6,6 @@ namespace WixToolset.Core.ExtensibilityServices
     using System.Collections.Generic;
     using WixToolset.Core.Bind;
     using WixToolset.Data;
-    using WixToolset.Data.Symbols;
-    using WixToolset.Data.WindowsInstaller.Rows;
     using WixToolset.Extensibility.Data;
     using WixToolset.Extensibility.Services;
 
@@ -17,21 +15,6 @@ namespace WixToolset.Core.ExtensibilityServices
         {
         }
 
-        public IFileFacade CreateFileFacade(FileSymbol file, AssemblySymbol assembly)
-        {
-            return new FileFacade(file, assembly);
-        }
-
-        public IFileFacade CreateFileFacade(FileRow fileRow)
-        {
-            return new FileFacade(fileRow);
-        }
-
-        public IFileFacade CreateFileFacadeFromMergeModule(FileSymbol fileSymbol)
-        {
-            return new FileFacade(true, fileSymbol);
-        }
-
         public string CreateGuid()
         {
             return Common.GenerateGuid();
diff --git a/src/wix/WixToolset.Core/ExtensibilityServices/FileFacade.cs b/src/wix/WixToolset.Core/ExtensibilityServices/FileFacade.cs
deleted file mode 100644
index 65043658..00000000
--- a/src/wix/WixToolset.Core/ExtensibilityServices/FileFacade.cs
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
-
-namespace WixToolset.Core.ExtensibilityServices
-{
-    using System;
-    using System.Collections.Generic;
-    using WixToolset.Data;
-    using WixToolset.Data.Symbols;
-    using WixToolset.Data.WindowsInstaller;
-    using WixToolset.Data.WindowsInstaller.Rows;
-    using WixToolset.Extensibility.Data;
-
-    internal class FileFacade : IFileFacade
-    {
-        public FileFacade(FileSymbol file, AssemblySymbol assembly)
-        {
-            this.FileSymbol = file;
-            this.AssemblySymbol = assembly;
-
-            this.Identifier = file.Id;
-            this.ComponentRef = file.ComponentRef;
-        }
-
-        public FileFacade(bool fromModule, FileSymbol file)
-        {
-            this.FromModule = fromModule;
-            this.FileSymbol = file;
-
-            this.Identifier = file.Id;
-            this.ComponentRef = file.ComponentRef;
-        }
-
-        public FileFacade(FileRow row)
-        {
-            this.FromTransform = true;
-            this.FileRow = row;
-
-            this.Identifier = new Identifier(AccessModifier.Section, row.File);
-            this.ComponentRef = row.Component;
-        }
-
-        public bool FromModule { get; }
-
-        public bool FromTransform { get; }
-
-        private FileRow FileRow { get; }
-
-        private FileSymbol FileSymbol { get; }
-
-        private AssemblySymbol AssemblySymbol { get; }
-
-        public string Id => this.Identifier.Id;
-
-        public Identifier Identifier { get; }
-
-        public string ComponentRef { get; }
-
-        public int DiskId
-        {
-            get => this.FileRow == null ? this.FileSymbol.DiskId ?? 1 : this.FileRow.DiskId;
-            set
-            {
-                if (this.FileRow == null)
-                {
-                    this.FileSymbol.DiskId = value;
-                }
-                else
-                {
-                    this.FileRow.DiskId = value;
-                }
-            }
-        }
-
-        public string FileName => this.FileRow == null ? this.FileSymbol.Name : this.FileRow.FileName;
-
-        public int FileSize
-        {
-            get => this.FileRow == null ? this.FileSymbol.FileSize : this.FileRow.FileSize;
-            set
-            {
-                if (this.FileRow == null)
-                {
-                    this.FileSymbol.FileSize = value;
-                }
-                else
-                {
-                    this.FileRow.FileSize = value;
-                }
-            }
-        }
-
-        public string Language
-        {
-            get => this.FileRow == null ? this.FileSymbol.Language : this.FileRow.Language;
-            set
-            {
-                if (this.FileRow == null)
-                {
-                    this.FileSymbol.Language = value;
-                }
-                else
-                {
-                    this.FileRow.Language = value;
-                }
-            }
-        }
-
-        public int? PatchGroup => this.FileRow == null ? this.FileSymbol.PatchGroup : null;
-
-        public int Sequence
-        {
-            get => this.FileRow == null ? this.FileSymbol.Sequence : this.FileRow.Sequence;
-            set
-            {
-                if (this.FileRow == null)
-                {
-                    this.FileSymbol.Sequence = value;
-                }
-                else
-                {
-                    this.FileRow.Sequence = value;
-                }
-            }
-        }
-
-        public SourceLineNumber SourceLineNumber => this.FileRow == null ? this.FileSymbol.SourceLineNumbers : this.FileRow.SourceLineNumbers;
-
-        public string SourcePath => this.FileRow == null ? this.FileSymbol.Source?.Path : this.FileRow.Source;
-
-        public bool Compressed => this.FileRow == null ? (this.FileSymbol.Attributes & FileSymbolAttributes.Compressed) == FileSymbolAttributes.Compressed : (this.FileRow.Attributes & WindowsInstallerConstants.MsidbFileAttributesCompressed) == WindowsInstallerConstants.MsidbFileAttributesCompressed;
-
-        public bool Uncompressed => this.FileRow == null ? (this.FileSymbol.Attributes & FileSymbolAttributes.Uncompressed) == FileSymbolAttributes.Uncompressed : (this.FileRow.Attributes & WindowsInstallerConstants.MsidbFileAttributesNoncompressed) == WindowsInstallerConstants.MsidbFileAttributesNoncompressed;
-
-        public string Version
-        {
-            get => this.FileRow == null ? this.FileSymbol.Version : this.FileRow.Version;
-            set
-            {
-                if (this.FileRow == null)
-                {
-                    this.FileSymbol.Version = value;
-                }
-                else
-                {
-                    this.FileRow.Version = value;
-                }
-            }
-        }
-
-        public AssemblyType? AssemblyType => this.FileRow == null ? this.AssemblySymbol?.Type : null;
-
-        public string AssemblyApplicationFileRef => this.FileRow == null ? this.AssemblySymbol?.ApplicationFileRef : throw new NotImplementedException();
-
-        public string AssemblyManifestFileRef => this.FileRow == null ? this.AssemblySymbol?.ManifestFileRef : throw new NotImplementedException();
-
-        /// <summary>
-        /// Gets the set of MsiAssemblyName rows created for this file.
-        /// </summary>
-        /// <value>RowCollection of MsiAssemblyName table.</value>
-        public List<MsiAssemblyNameSymbol> AssemblyNames { get; set; }
-
-        /// <summary>
-        /// Gets or sets the MsiFileHash row for this file.
-        /// </summary>
-        public MsiFileHashSymbol Hash { get; set; }
-
-        /// <summary>
-        /// Allows direct access to the underlying FileRow as requried for patching.
-        /// </summary>
-        public FileRow GetFileRow()
-        {
-            return this.FileRow ?? throw new NotImplementedException();
-        }
-    }
-}
diff --git a/src/wix/WixToolset.Core/Bind/FileResolver.cs b/src/wix/WixToolset.Core/ExtensibilityServices/FileResolver.cs
index eb878239..8f08e75e 100644
--- a/src/wix/WixToolset.Core/Bind/FileResolver.cs
+++ b/src/wix/WixToolset.Core/ExtensibilityServices/FileResolver.cs
@@ -1,51 +1,24 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
 
-namespace WixToolset.Core.Bind
+namespace WixToolset.Core.ExtensibilityServices
 {
     using System;
     using System.Collections.Generic;
     using System.IO;
-    using System.Linq;
     using WixToolset.Data;
     using WixToolset.Extensibility;
     using WixToolset.Extensibility.Data;
+    using WixToolset.Extensibility.Services;
 
-    internal class FileResolver
+    internal class FileResolver : IFileResolver
     {
         private const string BindPathOpenString = "!(bindpath.";
 
-        private FileResolver(IEnumerable<IBindPath> bindPaths)
-        {
-            this.BindPaths = (bindPaths ?? Array.Empty<IBindPath>()).ToLookup(b => b.Stage);
-            this.RebaseTarget = this.BindPaths[BindStage.Target].Any();
-            this.RebaseUpdated = this.BindPaths[BindStage.Updated].Any();
-        }
-
-        public FileResolver(IEnumerable<IBindPath> bindPaths, IEnumerable<IResolverExtension> extensions) : this(bindPaths)
-        {
-            this.ResolverExtensions = extensions ?? Array.Empty<IResolverExtension>();
-        }
-
-        public FileResolver(IEnumerable<IBindPath> bindPaths, IEnumerable<ILibrarianExtension> extensions) : this(bindPaths)
-        {
-            this.LibrarianExtensions = extensions ?? Array.Empty<ILibrarianExtension>();
-        }
-
-        private ILookup<BindStage, IBindPath> BindPaths { get; }
-
-        public bool RebaseTarget { get; }
-
-        public bool RebaseUpdated { get; }
-
-        private IEnumerable<IResolverExtension> ResolverExtensions { get; }
-
-        private IEnumerable<ILibrarianExtension> LibrarianExtensions { get; }
-
-        public string Resolve(SourceLineNumber sourceLineNumbers, IntermediateSymbolDefinition symbolDefinition, string source)
+        public string ResolveFile(string source, IEnumerable<ILibrarianExtension> librarianExtensions, IEnumerable<IBindPath> bindPaths, SourceLineNumber sourceLineNumbers, IntermediateSymbolDefinition symbolDefinition)
         {
             var checkedPaths = new List<string>();
 
-            foreach (var extension in this.LibrarianExtensions)
+            foreach (var extension in librarianExtensions)
             {
                 var resolved = extension.ResolveFile(sourceLineNumbers, symbolDefinition, source);
 
@@ -60,19 +33,10 @@ namespace WixToolset.Core.Bind
                 }
             }
 
-            return this.MustResolveUsingBindPaths(source, symbolDefinition, sourceLineNumbers, BindStage.Normal, checkedPaths);
+            return this.MustResolveUsingBindPaths(source, symbolDefinition, sourceLineNumbers, bindPaths, checkedPaths);
         }
 
-        /// <summary>
-        /// Resolves the source path of a file using binder extensions.
-        /// </summary>
-        /// <param name="source">Original source value.</param>
-        /// <param name="symbolDefinition">Optional type of source file being resolved.</param>
-        /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param>
-        /// <param name="bindStage">The binding stage used to determine what collection of bind paths will be used</param>
-        /// <param name="alreadyCheckedPaths">Optional collection of paths already checked.</param>
-        /// <returns>Should return a valid path for the stream to be imported.</returns>
-        public string ResolveFile(string source, IntermediateSymbolDefinition symbolDefinition, SourceLineNumber sourceLineNumbers, BindStage bindStage, IEnumerable<string> alreadyCheckedPaths = null)
+        public string ResolveFile(string source, IEnumerable<IResolverExtension> resolverExtensions, IEnumerable<IBindPath> bindPaths, BindStage bindStage, SourceLineNumber sourceLineNumbers, IntermediateSymbolDefinition symbolDefinition, IEnumerable<string> alreadyCheckedPaths = null)
         {
             var checkedPaths = new List<string>();
 
@@ -81,7 +45,7 @@ namespace WixToolset.Core.Bind
                 checkedPaths.AddRange(alreadyCheckedPaths);
             }
 
-            foreach (var extension in this.ResolverExtensions)
+            foreach (var extension in resolverExtensions)
             {
                 var resolved = extension.ResolveFile(source, symbolDefinition, sourceLineNumbers, bindStage);
 
@@ -96,10 +60,10 @@ namespace WixToolset.Core.Bind
                 }
             }
 
-            return this.MustResolveUsingBindPaths(source, symbolDefinition, sourceLineNumbers, bindStage, checkedPaths);
+            return this.MustResolveUsingBindPaths(source, symbolDefinition, sourceLineNumbers, bindPaths, checkedPaths);
         }
 
-        private string MustResolveUsingBindPaths(string source, IntermediateSymbolDefinition symbolDefinition, SourceLineNumber sourceLineNumbers, BindStage bindStage, List<string> checkedPaths)
+        private string MustResolveUsingBindPaths(string source, IntermediateSymbolDefinition symbolDefinition, SourceLineNumber sourceLineNumbers, IEnumerable<IBindPath> bindPaths, List<string> checkedPaths)
         {
             string resolved = null;
 
@@ -135,8 +99,6 @@ namespace WixToolset.Core.Bind
                     pathWithoutSourceDir = path.Substring(10);
                 }
 
-                var bindPaths = this.BindPaths[bindStage];
-
                 foreach (var bindPath in bindPaths)
                 {
                     if (String.IsNullOrEmpty(bindName))
@@ -145,36 +107,18 @@ namespace WixToolset.Core.Bind
                         {
                             if (!String.IsNullOrEmpty(pathWithoutSourceDir))
                             {
-                                var filePath = Path.Combine(bindPath.Path, pathWithoutSourceDir);
-
-                                checkedPaths.Add(filePath);
-                                if (CheckFileExists(filePath))
-                                {
-                                    resolved = filePath;
-                                }
+                                resolved = ResolveWithBindPath(bindPath.Path, pathWithoutSourceDir, checkedPaths);
                             }
 
                             if (String.IsNullOrEmpty(resolved))
                             {
-                                var filePath = Path.Combine(bindPath.Path, path);
-
-                                checkedPaths.Add(filePath);
-                                if (CheckFileExists(filePath))
-                                {
-                                    resolved = filePath;
-                                }
+                                resolved = ResolveWithBindPath(bindPath.Path, path, checkedPaths);
                             }
                         }
                     }
                     else if (bindName.Equals(bindPath.Name, StringComparison.OrdinalIgnoreCase))
                     {
-                        var filePath = Path.Combine(bindPath.Path, path);
-
-                        checkedPaths.Add(filePath);
-                        if (CheckFileExists(filePath))
-                        {
-                            resolved = filePath;
-                        }
+                        resolved = ResolveWithBindPath(bindPath.Path, path, checkedPaths);
                     }
 
                     if (!String.IsNullOrEmpty(resolved))
@@ -186,12 +130,26 @@ namespace WixToolset.Core.Bind
 
             if (null == resolved)
             {
-                throw new WixException(ErrorMessages.FileNotFound(sourceLineNumbers, source, symbolDefinition.Name, checkedPaths));
+                throw new WixException(ErrorMessages.FileNotFound(sourceLineNumbers, source, symbolDefinition?.Name, checkedPaths));
             }
 
             return resolved;
         }
 
+        private static string ResolveWithBindPath(string bindPath, string relativePath, List<string> checkedPaths)
+        {
+            var filePath = Path.Combine(bindPath, relativePath);
+
+            checkedPaths.Add(filePath);
+
+            if (CheckFileExists(filePath))
+            {
+                return filePath;
+            }
+
+            return null;
+        }
+
         private static bool CheckFileExists(string path)
         {
             try
diff --git a/src/wix/WixToolset.Core/Librarian.cs b/src/wix/WixToolset.Core/Librarian.cs
index 2762fb33..968dd946 100644
--- a/src/wix/WixToolset.Core/Librarian.cs
+++ b/src/wix/WixToolset.Core/Librarian.cs
@@ -5,7 +5,6 @@ namespace WixToolset.Core
     using System;
     using System.Collections.Generic;
     using System.Linq;
-    using WixToolset.Core.Bind;
     using WixToolset.Core.Link;
     using WixToolset.Data;
     using WixToolset.Extensibility.Data;
@@ -21,6 +20,7 @@ namespace WixToolset.Core
             this.ServiceProvider = serviceProvider;
 
             this.Messaging = this.ServiceProvider.GetService<IMessaging>();
+            this.FileResolver = this.ServiceProvider.GetService<IFileResolver>();
             this.LayoutServices = this.ServiceProvider.GetService<ILayoutServices>();
         }
 
@@ -28,6 +28,8 @@ namespace WixToolset.Core
 
         private IMessaging Messaging { get; }
 
+        private IFileResolver FileResolver { get; }
+
         private ILayoutServices LayoutServices { get; }
 
         /// <summary>
@@ -97,7 +99,7 @@ namespace WixToolset.Core
             {
                 var variableResolver = this.ServiceProvider.GetService<IVariableResolver>();
 
-                var fileResolver = new FileResolver(context.BindPaths, context.Extensions);
+                var bindPaths = context.BindPaths.Where(b => b.Stage == BindStage.Normal).ToList();
 
                 foreach (var symbol in sections.SelectMany(s => s.Symbols))
                 {
@@ -109,7 +111,7 @@ namespace WixToolset.Core
                         {
                             var resolution = variableResolver.ResolveVariables(symbol.SourceLineNumbers, pathField.Path);
 
-                            var file = fileResolver.Resolve(symbol.SourceLineNumbers, symbol.Definition, resolution.Value);
+                            var file = this.FileResolver.ResolveFile(resolution.Value, context.Extensions, bindPaths, symbol.SourceLineNumbers, symbol.Definition);
 
                             if (!String.IsNullOrEmpty(file))
                             {
diff --git a/src/wix/WixToolset.Core/Resolver.cs b/src/wix/WixToolset.Core/Resolver.cs
index e93f8e1b..f7aa6ff9 100644
--- a/src/wix/WixToolset.Core/Resolver.cs
+++ b/src/wix/WixToolset.Core/Resolver.cs
@@ -23,12 +23,16 @@ namespace WixToolset.Core
             this.ServiceProvider = serviceProvider;
 
             this.Messaging = serviceProvider.GetService<IMessaging>();
+
+            this.FileResolver = serviceProvider.GetService<IFileResolver>();
         }
 
         private IServiceProvider ServiceProvider { get; }
 
         private IMessaging Messaging { get; }
 
+        private IFileResolver FileResolver { get; }
+
         public IResolveResult Resolve(IResolveContext context)
         {
             foreach (var extension in context.Extensions)
@@ -45,7 +49,7 @@ namespace WixToolset.Core
 
                 this.LocalizeUI(variableResolver, context.IntermediateRepresentation);
 
-                resolveResult = this.DoResolve(context, variableResolver);
+                resolveResult = this.ResolveFields(context, variableResolver);
 
                 var primaryLocalization = filteredLocalizations.FirstOrDefault();
 
@@ -71,49 +75,18 @@ namespace WixToolset.Core
             return resolveResult;
         }
 
-        private ResolveResult DoResolve(IResolveContext context, IVariableResolver variableResolver)
+        private ResolveResult ResolveFields(IResolveContext context, IVariableResolver variableResolver)
         {
-            var buildingPatch = context.IntermediateRepresentation.Sections.Any(s => s.Type == SectionType.Patch);
-
             var filesWithEmbeddedFiles = new ExtractEmbeddedFiles();
 
             IReadOnlyCollection<DelayedField> delayedFields;
             {
-                var command = new ResolveFieldsCommand();
-                command.Messaging = this.Messaging;
-                command.BuildingPatch = buildingPatch;
-                command.VariableResolver = variableResolver;
-                command.BindPaths = context.BindPaths;
-                command.Extensions = context.Extensions;
-                command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
-                command.IntermediateFolder = context.IntermediateFolder;
-                command.Intermediate = context.IntermediateRepresentation;
-                command.SupportDelayedResolution = true;
-                command.AllowUnresolvedVariables = context.AllowUnresolvedVariables;
+                var command = new ResolveFieldsCommand(this.Messaging, this.FileResolver, variableResolver, context.BindPaths, context.Extensions, filesWithEmbeddedFiles, context.IntermediateFolder, context.IntermediateRepresentation, context.AllowUnresolvedVariables);
                 command.Execute();
 
                 delayedFields = command.DelayedFields;
             }
 
-#if TODO_PATCHING
-            if (context.IntermediateRepresentation.SubStorages != null)
-            {
-                foreach (SubStorage transform in context.IntermediateRepresentation.SubStorages)
-                {
-                    var command = new ResolveFieldsCommand();
-                    command.BuildingPatch = buildingPatch;
-                    command.BindVariableResolver = context.WixVariableResolver;
-                    command.BindPaths = context.BindPaths;
-                    command.Extensions = context.Extensions;
-                    command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
-                    command.IntermediateFolder = context.IntermediateFolder;
-                    command.Intermediate = context.IntermediateRepresentation;
-                    command.SupportDelayedResolution = false;
-                    command.Execute();
-                }
-            }
-#endif
-
             var expectedEmbeddedFiles = filesWithEmbeddedFiles.GetExpectedEmbeddedFiles();
 
             context.IntermediateRepresentation.UpdateLevel(IntermediateLevels.Resolved);
diff --git a/src/wix/WixToolset.Core/WixToolsetServiceProvider.cs b/src/wix/WixToolset.Core/WixToolsetServiceProvider.cs
index fa6b369d..5620bcd2 100644
--- a/src/wix/WixToolset.Core/WixToolsetServiceProvider.cs
+++ b/src/wix/WixToolset.Core/WixToolsetServiceProvider.cs
@@ -27,6 +27,7 @@ namespace WixToolset.Core
             this.AddService((provider, singletons) => AddSingleton<ILayoutServices>(singletons, new LayoutServices(provider)));
             this.AddService((provider, singletons) => AddSingleton<IBackendHelper>(singletons, new BackendHelper(provider)));
             this.AddService((provider, singletons) => AddSingleton<IPathResolver>(singletons, new PathResolver()));
+            this.AddService((provider, singletons) => AddSingleton<IFileResolver>(singletons, new FileResolver()));
             this.AddService((provider, singletons) => AddSingleton<IFileSystem>(singletons, new FileSystem()));
             this.AddService((provider, singletons) => AddSingleton<IWixBranding>(singletons, new WixBranding()));
 
diff --git a/src/wix/test/WixToolsetTest.CoreIntegration/PatchFixture.cs b/src/wix/test/WixToolsetTest.CoreIntegration/PatchFixture.cs
index a8aff8d8..c330fd02 100644
--- a/src/wix/test/WixToolsetTest.CoreIntegration/PatchFixture.cs
+++ b/src/wix/test/WixToolsetTest.CoreIntegration/PatchFixture.cs
@@ -5,6 +5,7 @@ namespace WixToolsetTest.CoreIntegration
     using System;
     using System.Collections.Generic;
     using System.ComponentModel;
+    using System.Diagnostics;
     using System.IO;
     using System.Linq;
     using System.Runtime.InteropServices;
@@ -22,8 +23,11 @@ namespace WixToolsetTest.CoreIntegration
     public class PatchFixture : IDisposable
     {
         private static readonly XNamespace PatchNamespace = "http://www.microsoft.com/msi/patch_applicability.xsd";
+        private static readonly XName TargetProductCodeName = PatchNamespace + "TargetProductCode";
+
         private readonly DisposableFileSystem tempFileSystem;
         private readonly string tempBaseFolder;
+        private readonly string templateSourceFolder;
         private readonly string templateBaselinePdb;
         private readonly string templateUpdatePdb;
         private readonly string templateUpdateNoFilesChangedPdb;
@@ -33,14 +37,14 @@ namespace WixToolsetTest.CoreIntegration
             this.tempFileSystem = new DisposableFileSystem();
             this.tempBaseFolder = this.tempFileSystem.GetFolder();
 
-            var templateSourceFolder = TestData.Get(@"TestData", "PatchTemplatePackage");
+            this.templateSourceFolder = TestData.Get(@"TestData", "PatchTemplatePackage");
             var tempFolderBaseline = Path.Combine(this.tempBaseFolder, "PatchTemplatePackage", "baseline");
             var tempFolderUpdate = Path.Combine(this.tempBaseFolder, "PatchTemplatePackage", "update");
             var tempFolderUpdateNoFileChanges = Path.Combine(this.tempBaseFolder, "PatchTemplatePackage", "updatewithoutfilechanges");
 
-            this.templateBaselinePdb = BuildMsi("Baseline.msi", templateSourceFolder, tempFolderBaseline, "1.0.0", "1.0.0", "1.0.0", new[] { Path.Combine(templateSourceFolder, ".baseline-data") });
-            this.templateUpdatePdb = BuildMsi("Update.msi", templateSourceFolder, tempFolderUpdate, "1.0.1", "1.0.1", "1.0.1", new[] { Path.Combine(templateSourceFolder, ".update-data") });
-            this.templateUpdateNoFilesChangedPdb = BuildMsi("Update.msi", templateSourceFolder, tempFolderUpdateNoFileChanges, "1.0.1", "1.0.1", "1.0.1", new[] { Path.Combine(templateSourceFolder, ".baseline-data") });
+            this.templateBaselinePdb = BuildMsi("Baseline.msi", this.templateSourceFolder, tempFolderBaseline, "1.0.0", "1.0.0", "1.0.0", new[] { Path.Combine(this.templateSourceFolder, ".baseline-data") });
+            this.templateUpdatePdb = BuildMsi("Update.msi", this.templateSourceFolder, tempFolderUpdate, "1.0.1", "1.0.1", "1.0.1", new[] { Path.Combine(this.templateSourceFolder, ".update-data") });
+            this.templateUpdateNoFilesChangedPdb = BuildMsi("Update.msi", this.templateSourceFolder, tempFolderUpdateNoFileChanges, "1.0.1", "1.0.1", "1.0.1", new[] { Path.Combine(this.templateSourceFolder, ".baseline-data") });
         }
 
         public void Dispose()
@@ -49,7 +53,7 @@ namespace WixToolsetTest.CoreIntegration
         }
 
         [Fact]
-        public void CanBuildSimplePatch()
+        public void CanBuildSimplePatchUsingWixpdbs()
         {
             var folder = TestData.Get(@"TestData", "PatchSingle");
 
@@ -66,14 +70,13 @@ namespace WixToolsetTest.CoreIntegration
                 Assert.True(File.Exists(update1Pdb));
 
                 var doc = GetExtractPatchXml(patchPath);
-                WixAssert.StringEqual("{7D326855-E790-4A94-8611-5351F8321FCA}", doc.Root.Element(PatchNamespace + "TargetProductCode").Value);
+                WixAssert.StringEqual("{7D326855-E790-4A94-8611-5351F8321FCA}", doc.Root.Element(TargetProductCodeName).Value);
 
                 var names = Query.GetSubStorageNames(patchPath);
                 WixAssert.CompareLineByLine(new[] { "#RTM.1", "RTM.1" }, names);
 
                 var cab = Path.Combine(tempFolder, "foo.cab");
                 Query.ExtractStream(patchPath, "foo.cab", cab);
-                Assert.True(File.Exists(cab));
 
                 var files = Query.GetCabinetFiles(cab);
                 WixAssert.CompareLineByLine(new[] { "a.txt", "b.txt" }, files.Select(f => f.Name).ToArray());
@@ -81,7 +84,37 @@ namespace WixToolsetTest.CoreIntegration
         }
 
         [Fact]
-        public void CanBuildSimplePatchWithFileChanges()
+        public void CanBuildSimplePatchWithFileChangesUsingMsi()
+        {
+            var sourceFolder = TestData.Get(@"TestData", "PatchWithFileChangesUsingMsi");
+
+            using (var fs = new DisposableFileSystem())
+            {
+                var baseFolder = fs.GetFolder();
+                var tempFolderPatch = Path.Combine(baseFolder, "patch");
+
+                var patchPdb = BuildMsp("Patch1.msp", sourceFolder, tempFolderPatch, "1.0.1", bindpaths: new[] { Path.GetDirectoryName(this.templateBaselinePdb), Path.GetDirectoryName(this.templateUpdatePdb) });
+                var patchPath = Path.ChangeExtension(patchPdb, ".msp");
+
+                var doc = GetExtractPatchXml(patchPath);
+                WixAssert.StringEqual("{11111111-2222-3333-4444-555555555555}", doc.Root.Element(TargetProductCodeName).Value);
+
+                var names = Query.GetSubStorageNames(patchPath);
+                WixAssert.CompareLineByLine(new[] { "#RTM.1", "RTM.1" }, names);
+
+                var cab = Path.Combine(baseFolder, "foo.cab");
+                Query.ExtractStream(patchPath, "foo.cab", cab);
+
+                var files = Query.GetCabinetFiles(cab);
+                var file = files.Single();
+                WixAssert.StringEqual("a.txt", file.Name);
+                var contents = file.OpenText().ReadToEnd();
+                WixAssert.StringEqual("This is A v1.0.1 from the '.update-data' folder in 'PatchTemplatePackage'.\r\n\r\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod.\r\n", contents);
+            }
+        }
+
+        [Fact]
+        public void CanBuildSimplePatchWithFileChangesUsingWixpdb()
         {
             var sourceFolder = TestData.Get(@"TestData", "PatchWithFileChanges");
 
@@ -94,7 +127,7 @@ namespace WixToolsetTest.CoreIntegration
                 var patchPath = Path.ChangeExtension(patchPdb, ".msp");
 
                 var doc = GetExtractPatchXml(patchPath);
-                WixAssert.StringEqual("{11111111-2222-3333-4444-555555555555}", doc.Root.Element(PatchNamespace + "TargetProductCode").Value);
+                WixAssert.StringEqual("{11111111-2222-3333-4444-555555555555}", doc.Root.Element(TargetProductCodeName).Value);
 
                 var names = Query.GetSubStorageNames(patchPath);
                 WixAssert.CompareLineByLine(new[] { "#RTM.1", "RTM.1" }, names);
@@ -106,11 +139,73 @@ namespace WixToolsetTest.CoreIntegration
                 var file = files.Single();
                 WixAssert.StringEqual("a.txt", file.Name);
                 var contents = file.OpenText().ReadToEnd();
-                WixAssert.StringEqual("This is A v1.0.1\r\n", contents);
+                WixAssert.StringEqual("This is A v1.0.1 from the '.update-data' folder in 'PatchTemplatePackage'.\r\n\r\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod.\r\n", contents);
             }
         }
 
         [Fact]
+        public void CanBuildSimplePatchWithFileChangesUsingWixpdbAndAlternativeUpdatedSourceFolder()
+        {
+            var sourceFolder = TestData.Get(@"TestData", "PatchWithFileChanges");
+
+            using (var fs = new DisposableFileSystem())
+            {
+                var baseFolder = fs.GetFolder();
+                var tempFolderPatch = Path.Combine(baseFolder, "patch");
+
+                var patchPdb = BuildMsp("Patch1.msp", sourceFolder, tempFolderPatch, "1.0.1", bindpaths: new[] { Path.GetDirectoryName(this.templateBaselinePdb), Path.GetDirectoryName(this.templateUpdatePdb) }, updateBindpaths: new[] { Path.Combine(this.templateSourceFolder, ".update-data-alternative") });
+                var patchPath = Path.ChangeExtension(patchPdb, ".msp");
+
+                var doc = GetExtractPatchXml(patchPath);
+                WixAssert.StringEqual("{11111111-2222-3333-4444-555555555555}", doc.Root.Element(TargetProductCodeName).Value);
+
+                var names = Query.GetSubStorageNames(patchPath);
+                WixAssert.CompareLineByLine(new[] { "#RTM.1", "RTM.1" }, names);
+
+                var cab = Path.Combine(baseFolder, "foo.cab");
+                Query.ExtractStream(patchPath, "foo.cab", cab);
+
+                var files = Query.GetCabinetFiles(cab);
+                var file = files.Single();
+                WixAssert.StringEqual("a.txt", file.Name);
+                var contents = file.OpenText().ReadToEnd();
+                WixAssert.StringEqual("This is A v1.0.1 from the '.update-data-alternative' folder in 'PatchTemplatePackage'.\r\n\r\nDiam quis enim lobortis scelerisque fermentum dui faucibus in ornare.\r\n", contents);
+            }
+        }
+
+        [Fact]
+        public void CanBuildPatchFromAdminImage()
+        {
+            var sourceFolder = TestData.Get(@"TestData", "PatchUsingAdminImages");
+
+            var baseFolder = this.tempFileSystem.GetFolder();
+            var tempFolderPatch = Path.Combine(baseFolder, "patch");
+            var adminBaselineFolder = Path.Combine(baseFolder, "admin-baseline");
+            var adminUpdateFolder = Path.Combine(baseFolder, "admin-update");
+
+            CreateAdminImage(this.templateBaselinePdb, adminBaselineFolder);
+            CreateAdminImage(this.templateUpdatePdb, adminUpdateFolder);
+
+            var patchPdb = BuildMsp("Patch1.msp", sourceFolder, tempFolderPatch, "1.0.1", bindpaths: new[] { adminBaselineFolder, adminUpdateFolder });
+            var patchPath = Path.ChangeExtension(patchPdb, ".msp");
+
+            var doc = GetExtractPatchXml(patchPath);
+            WixAssert.StringEqual("{11111111-2222-3333-4444-555555555555}", doc.Root.Element(TargetProductCodeName).Value);
+
+            var names = Query.GetSubStorageNames(patchPath);
+            WixAssert.CompareLineByLine(new[] { "#RTM.1", "RTM.1" }, names);
+
+            var cab = Path.Combine(baseFolder, "foo.cab");
+            Query.ExtractStream(patchPath, "foo.cab", cab);
+
+            var files = Query.GetCabinetFiles(cab);
+            var file = files.Single();
+            WixAssert.StringEqual("a.txt", file.Name);
+            var contents = file.OpenText().ReadToEnd();
+            WixAssert.StringEqual("This is A v1.0.1 from the '.update-data' folder in 'PatchTemplatePackage'.\r\n\r\nLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod.\r\n", contents);
+        }
+
+        [Fact]
         public void CanBuildSimplePatchWithNoFileChanges()
         {
             var folder = TestData.Get(@"TestData", "PatchNoFileChanges");
@@ -123,14 +218,13 @@ namespace WixToolsetTest.CoreIntegration
                 var patchPath = Path.ChangeExtension(patchPdb, ".msp");
 
                 var doc = GetExtractPatchXml(patchPath);
-                WixAssert.StringEqual("{11111111-2222-3333-4444-555555555555}", doc.Root.Element(PatchNamespace + "TargetProductCode").Value);
+                WixAssert.StringEqual("{11111111-2222-3333-4444-555555555555}", doc.Root.Element(TargetProductCodeName).Value);
 
                 var names = Query.GetSubStorageNames(patchPath);
                 WixAssert.CompareLineByLine(new[] { "#RTM.1", "RTM.1" }, names);
 
                 var cab = Path.Combine(tempFolder, "foo.cab");
                 Query.ExtractStream(patchPath, "foo.cab", cab);
-                Assert.True(File.Exists(cab));
 
                 var files = Query.GetCabinetFiles(cab);
                 Assert.Empty(files);
@@ -155,14 +249,13 @@ namespace WixToolsetTest.CoreIntegration
                 var patchPath = Path.ChangeExtension(patchPdb, ".msp");
 
                 var doc = GetExtractPatchXml(patchPath);
-                WixAssert.StringEqual("{7D326855-E790-4A94-8611-5351F8321FCA}", doc.Root.Element(PatchNamespace + "TargetProductCode").Value);
+                WixAssert.StringEqual("{7D326855-E790-4A94-8611-5351F8321FCA}", doc.Root.Element(TargetProductCodeName).Value);
 
                 var names = Query.GetSubStorageNames(patchPath);
                 WixAssert.CompareLineByLine(new[] { "#RTM.1", "RTM.1" }, names);
 
                 var cab = Path.Combine(baseFolder, "foo.cab");
                 Query.ExtractStream(patchPath, "foo.cab", cab);
-                Assert.True(File.Exists(cab));
 
                 var files = Query.GetCabinetFiles(cab);
                 var file = files.Single();
@@ -197,7 +290,7 @@ namespace WixToolsetTest.CoreIntegration
                 var patchPath = Path.ChangeExtension(patchPdb, ".msp");
 
                 var doc = GetExtractPatchXml(patchPath);
-                WixAssert.StringEqual("{11111111-2222-3333-4444-555555555555}", doc.Root.Element(PatchNamespace + "TargetProductCode").Value);
+                WixAssert.StringEqual("{11111111-2222-3333-4444-555555555555}", doc.Root.Element(TargetProductCodeName).Value);
 
                 var names = Query.GetSubStorageNames(patchPath);
                 WixAssert.CompareLineByLine(new[] { "#ThisBaseLineIdIsTooLongAndGe.1", "ThisBaseLineIdIsTooLongAndGe.1" }, names);
@@ -217,12 +310,12 @@ namespace WixToolsetTest.CoreIntegration
                 var tempFolderPatch = Path.Combine(baseFolder, "patch");
 
                 var baselinePdb = BuildMsi("Baseline.msi", sourceFolder, tempFolderBaseline, "1.0.0", "1.0.0", "1.0.0");
-                var update1Pdb = BuildMsi("Update.msi", sourceFolder, tempFolderUpdate, "1.0.1", "1.0.1", "1.0.1");
-                var patchPdb = BuildMsp("Patch1.msp", sourceFolder, tempFolderPatch, "1.0.1", bindpaths: new[] { Path.GetDirectoryName(baselinePdb), Path.GetDirectoryName(update1Pdb) }, hasNoFiles: true);
+                var updatePdb = BuildMsi("Update.msi", sourceFolder, tempFolderUpdate, "1.0.1", "1.0.1", "1.0.1");
+                var patchPdb = BuildMsp("Patch1.msp", sourceFolder, tempFolderPatch, "1.0.1", bindpaths: new[] { Path.GetDirectoryName(baselinePdb), Path.GetDirectoryName(updatePdb) }, hasNoFiles: true);
                 var patchPath = Path.ChangeExtension(patchPdb, ".msp");
 
-                Assert.True(File.Exists(baselinePdb));
-                Assert.True(File.Exists(update1Pdb));
+                var doc = GetExtractPatchXml(patchPath);
+                WixAssert.StringEqual("{7C871EC1-1F89-4850-A6A9-D7A4C21769F6}", doc.Root.Element(TargetProductCodeName).Value);
             }
         }
 
@@ -317,7 +410,28 @@ namespace WixToolsetTest.CoreIntegration
             return Path.ChangeExtension(outputPath, ".wixpdb");
         }
 
-        private static string BuildMsp(string outputName, string sourceFolder, string baseFolder, string defineV, IEnumerable<string> bindpaths = null, bool hasNoFiles = false, bool warningsAsErrors = true)
+        private static string BuildMst(string transformName, string baseFolder, string templateBaselinePdb, string templateUpdatePdb)
+        {
+            var outputPath = Path.Combine(baseFolder, transformName);
+
+            var args = new List<string>
+            {
+                "msi", "transform",
+                templateBaselinePdb,
+                templateUpdatePdb,
+                "-intermediateFolder", Path.Combine(baseFolder),
+                "-t", "patch",
+                "-o", outputPath,
+            };
+
+            var result = WixRunner.Execute(args.ToArray());
+
+            result.AssertSuccess();
+
+            return outputPath;
+        }
+
+        private static string BuildMsp(string outputName, string sourceFolder, string baseFolder, string defineV, IEnumerable<string> bindpaths = null, IEnumerable<string> targetBindpaths = null, IEnumerable<string> updateBindpaths = null, bool hasNoFiles = false, bool warningsAsErrors = true)
         {
             var outputPath = Path.Combine(baseFolder, Path.Combine("bin", outputName));
 
@@ -332,10 +446,22 @@ namespace WixToolsetTest.CoreIntegration
                 "-o", outputPath
             };
 
-            foreach (var additionaBindPath in bindpaths ?? Enumerable.Empty<string>())
+            foreach (var additionalBindPath in bindpaths ?? Enumerable.Empty<string>())
             {
                 args.Add("-bindpath");
-                args.Add(additionaBindPath);
+                args.Add(additionalBindPath);
+            }
+
+            foreach (var targetBindPath in targetBindpaths ?? Enumerable.Empty<string>())
+            {
+                args.Add("-bindpath:target");
+                args.Add(targetBindPath);
+            }
+
+            foreach (var updateBindpath in updateBindpaths ?? Enumerable.Empty<string>())
+            {
+                args.Add("-bindpath:update");
+                args.Add(updateBindpath);
             }
 
             var result = WixRunner.Execute(warningsAsErrors, args.ToArray());
@@ -365,6 +491,16 @@ namespace WixToolsetTest.CoreIntegration
             return Path.ChangeExtension(outputPath, ".wixpdb");
         }
 
+        private static void CreateAdminImage(string msiPath, string targetDir)
+        {
+            var args = $"/a {Path.ChangeExtension(msiPath, "msi")} TARGETDIR={targetDir} /qn";
+
+            var proc = Process.Start("msiexec.exe", args);
+            proc.WaitForExit(5000);
+
+            Assert.Equal(0, proc.ExitCode);
+        }
+
         private static XDocument GetExtractPatchXml(string path)
         {
             var buffer = new StringBuilder(65535);
diff --git a/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.baseline-data/A.txt b/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.baseline-data/A.txt
index 6fd385bd..f6c69979 100644
--- a/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.baseline-data/A.txt
+++ b/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.baseline-data/A.txt
@@ -1 +1 @@
-This is A v1.0.0
+This is A v1.0.0 from the "PatchTemplatePackage\.baseline-data" folder.
diff --git a/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.update-data-alternative/A.txt b/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.update-data-alternative/A.txt
new file mode 100644
index 00000000..17e8c861
--- /dev/null
+++ b/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.update-data-alternative/A.txt
@@ -0,0 +1,3 @@
+This is A v1.0.1 from the '.update-data-alternative' folder in 'PatchTemplatePackage'.
+
+Diam quis enim lobortis scelerisque fermentum dui faucibus in ornare.
diff --git a/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.update-data/A.txt b/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.update-data/A.txt
index f7ec8b4e..26832a47 100644
--- a/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.update-data/A.txt
+++ b/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchTemplatePackage/.update-data/A.txt
@@ -1 +1,3 @@
-This is A v1.0.1
+This is A v1.0.1 from the '.update-data' folder in 'PatchTemplatePackage'.
+
+Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod.
diff --git a/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchUsingAdminImages/Patch.wxs b/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchUsingAdminImages/Patch.wxs
new file mode 100644
index 00000000..f9ea1f5d
--- /dev/null
+++ b/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchUsingAdminImages/Patch.wxs
@@ -0,0 +1,16 @@
+<Wix xmlns='http://wixtoolset.org/schemas/v4/wxs'>
+  <Patch
+    AllowRemoval="yes"
+    DisplayName="~Test Patch v$(V)"
+    Description="~Test Small Update Patch v$(V)"
+    MoreInfoURL="http://www.example.com/"
+    Manufacturer="Example Corporation"
+    Classification="Update">
+
+    <Media Id="1" Cabinet="foo.cab">
+      <PatchBaseline Id="RTM" BaselineFile="Baseline.msi" UpdateFile="Update.msi" />
+    </Media>
+
+    <PatchFamily Id='SequenceFamily' Version='$(V)' />
+  </Patch>
+</Wix>
diff --git a/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchWithFileChangesUsingMsi/Patch.wxs b/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchWithFileChangesUsingMsi/Patch.wxs
new file mode 100644
index 00000000..f9ea1f5d
--- /dev/null
+++ b/src/wix/test/WixToolsetTest.CoreIntegration/TestData/PatchWithFileChangesUsingMsi/Patch.wxs
@@ -0,0 +1,16 @@
+<Wix xmlns='http://wixtoolset.org/schemas/v4/wxs'>
+  <Patch
+    AllowRemoval="yes"
+    DisplayName="~Test Patch v$(V)"
+    Description="~Test Small Update Patch v$(V)"
+    MoreInfoURL="http://www.example.com/"
+    Manufacturer="Example Corporation"
+    Classification="Update">
+
+    <Media Id="1" Cabinet="foo.cab">
+      <PatchBaseline Id="RTM" BaselineFile="Baseline.msi" UpdateFile="Update.msi" />
+    </Media>
+
+    <PatchFamily Id='SequenceFamily' Version='$(V)' />
+  </Patch>
+</Wix>